initial checkin

stb.h

@@ -0,0 +1,14082 @@
+/* stb-2.23 - Sean's Tool Box -- public domain -- http://nothings.org/stb.h
+          no warranty is offered or implied; use this code at your own risk
+
+   This is a single header file with a bunch of useful utilities
+   for getting stuff done in C/C++.
+
+   Email bug reports, feature requests, etc. to 'sean' at the same site.
+
+
+   Documentation: http://nothings.org/stb/stb_h.html
+   Unit tests:    http://nothings.org/stb/stb.c
+
+
+ ============================================================================
+   You MUST                                                                  
+                                                                             
+      #define STB_DEFINE                                                     
+                                                                             
+   in EXACTLY _one_ C or C++ file that includes this header, BEFORE the
+   include, like this:                                                                
+                                                                             
+      #define STB_DEFINE                                                     
+      #include "stb.h"
+      
+   All other files should just #include "stb.h" without the #define.
+ ============================================================================
+
+
+Version History
+
+   2.23   fix 2.22
+   2.22   64-bit fixes from '!='; fix stb_sdict_copy() to have preferred name
+   2.21   utf-8 decoder rejects "overlong" encodings; attempted 64-bit improvements
+   2.20   fix to hash "copy" function--reported by someone with handle "!="
+   2.19   ???
+   2.18   stb_readdir_subdirs_mask
+   2.17   stb_cfg_dir
+   2.16   fix stb_bgio_, add stb_bgio_stat(); begin a streaming wrapper
+   2.15   upgraded hash table template to allow:
+            - aggregate keys (explicit comparison func for EMPTY and DEL keys)
+            - "static" implementations (so they can be culled if unused)
+   2.14   stb_mprintf
+   2.13   reduce identifiable strings in STB_NO_STB_STRINGS
+   2.12   fix STB_ONLY -- lots of uint32s, TRUE/FALSE things had crept in
+   2.11   fix bug in stb_dirtree_get() which caused "c://path" sorts of stuff
+   2.10   STB_F(), STB_I() inline constants (also KI,KU,KF,KD)
+   2.09   stb_box_face_vertex_axis_side
+   2.08   bugfix stb_trimwhite()
+   2.07   colored printing in windows (why are we in 1985?)
+   2.06   comparison functions are now functions-that-return-functions and
+          accept a struct-offset as a parameter (not thread-safe)
+   2.05   compile and pass tests under Linux (but no threads); thread cleanup
+   2.04   stb_cubic_bezier_1d, smoothstep, avoid dependency on registry
+   2.03   ?
+   2.02   remove integrated documentation
+   2.01   integrate various fixes; stb_force_uniprocessor
+   2.00   revised stb_dupe to use multiple hashes
+   1.99   stb_charcmp
+   1.98   stb_arr_deleten, stb_arr_insertn
+   1.97   fix stb_newell_normal()
+   1.96   stb_hash_number()
+   1.95   hack stb__rec_max; clean up recursion code to use new functions
+   1.94   stb_dirtree; rename stb_extra to stb_ptrmap
+   1.93   stb_sem_new() API cleanup (no blockflag-starts blocked; use 'extra')
+   1.92   stb_threadqueue--multi reader/writer queue, fixed size or resizeable
+   1.91   stb_bgio_* for reading disk asynchronously
+   1.90   stb_mutex uses CRITICAL_REGION; new stb_sync primitive for thread
+          joining; workqueue supports stb_sync instead of stb_semaphore
+   1.89   support ';' in constant-string wildcards; stb_mutex wrapper (can
+          implement with EnterCriticalRegion eventually)
+   1.88   portable threading API (only for win32 so far); worker thread queue
+   1.87   fix wildcard handling in stb_readdir_recursive
+   1.86   support ';' in wildcards
+   1.85   make stb_regex work with non-constant strings;
+               beginnings of stb_introspect()
+   1.84   (forgot to make notes)
+   1.83   whoops, stb_keep_if_different wasn't deleting the temp file
+   1.82   bring back stb_compress from stb_file.h for cmirror
+   1.81   various bugfixes, STB_FASTMALLOC_INIT inits FASTMALLOC in release
+   1.80   stb_readdir returns utf8; write own utf8-utf16 because lib was wrong
+   1.79   stb_write
+   1.78   calloc() support for malloc wrapper, STB_FASTMALLOC
+   1.77   STB_FASTMALLOC
+   1.76   STB_STUA - Lua-like language; (stb_image, stb_csample, stb_bilinear)
+   1.75   alloc/free array of blocks; stb_hheap bug; a few stb_ps_ funcs;
+          hash*getkey, hash*copy; stb_bitset; stb_strnicmp; bugfix stb_bst
+   1.74   stb_replaceinplace; use stdlib C function to convert utf8 to UTF-16
+   1.73   fix performance bug & leak in stb_ischar (C++ port lost a 'static')
+   1.72   remove stb_block, stb_block_manager, stb_decompress (to stb_file.h)
+   1.71   stb_trimwhite, stb_tokens_nested, etc.
+   1.70   back out 1.69 because it might problemize mixed builds; stb_filec()
+   1.69   (stb_file returns 'char *' in C++)
+   1.68   add a special 'tree root' data type for stb_bst; stb_arr_end
+   1.67   full C++ port. (stb_block_manager)
+   1.66   stb_newell_normal
+   1.65   stb_lex_item_wild -- allow wildcard items which MUST match entirely
+   1.64   stb_data
+   1.63   stb_log_name
+   1.62   stb_define_sort; C++ cleanup
+   1.61   stb_hash_fast -- Paul Hsieh's hash function (beats Bob Jenkins'?)
+   1.60   stb_delete_directory_recursive
+   1.59   stb_readdir_recursive
+   1.58   stb_bst variant with parent pointer for O(1) iteration, not O(log N)
+   1.57   replace LCG random with Mersenne Twister (found a public domain one)
+   1.56   stb_perfect_hash, stb_ischar, stb_regex
+   1.55   new stb_bst API allows multiple BSTs per node (e.g. secondary keys)
+   1.54   bugfix: stb_define_hash, stb_wildmatch, regexp
+   1.53   stb_define_hash; recoded stb_extra, stb_sdict use it
+   1.52   stb_rand_define, stb_bst, stb_reverse
+   1.51   fix 'stb_arr_setlen(NULL, 0)'
+   1.50   stb_wordwrap
+   1.49   minor improvements to enable the scripting language
+   1.48   better approach for stb_arr using stb_malloc; more invasive, clearer
+   1.47   stb_lex (lexes stb.h at 1.5ML/s on 3Ghz P4; 60/70% of optimal/flex)
+   1.46   stb_wrapper_*, STB_MALLOC_WRAPPER
+   1.45   lightly tested DFA acceleration of regexp searching
+   1.44   wildcard matching & searching; regexp matching & searching
+   1.43   stb_temp
+   1.42   allow stb_arr to use stb_malloc/realloc; note this is global
+   1.41   make it compile in C++; (disable stb_arr in C++)
+   1.40   stb_dupe tweak; stb_swap; stb_substr
+   1.39   stb_dupe; improve stb_file_max to be less stupid
+   1.38   stb_sha1_file: generate sha1 for file, even > 4GB
+   1.37   stb_file_max; partial support for utf8 filenames in Windows
+   1.36   remove STB__NO_PREFIX - poor interaction with IDE, not worth it
+          streamline stb_arr to make it separately publishable
+   1.35   bugfixes for stb_sdict, stb_malloc(0), stristr
+   1.34   (streaming interfaces for stb_compress)
+   1.33   stb_alloc; bug in stb_getopt; remove stb_overflow
+   1.32   (stb_compress returns, smaller&faster; encode window & 64-bit len)
+   1.31   stb_prefix_count
+   1.30   (STB__NO_PREFIX - remove stb_ prefixes for personal projects)
+   1.29   stb_fput_varlen64, etc.
+   1.28   stb_sha1
+   1.27   ?
+   1.26   stb_extra
+   1.25   ?
+   1.24   stb_copyfile
+   1.23   stb_readdir
+   1.22   ?
+   1.21   ?
+   1.20   ?
+   1.19   ?
+   1.18   ?
+   1.17   ?
+   1.16   ?
+   1.15   stb_fixpath, stb_splitpath, stb_strchr2
+   1.14   stb_arr
+   1.13   ?stb, stb_log, stb_fatal
+   1.12   ?stb_hash2
+   1.11   miniML
+   1.10   stb_crc32, stb_adler32
+   1.09   stb_sdict
+   1.08   stb_bitreverse, stb_ispow2, stb_big32
+          stb_fopen, stb_fput_varlen, stb_fput_ranged
+          stb_fcmp, stb_feq
+   1.07   (stb_encompress)
+   1.06   stb_compress
+   1.05   stb_tokens, (stb_hheap)
+   1.04   stb_rand
+   1.03   ?(s-strings)
+   1.02   ?stb_filelen, stb_tokens
+   1.01   stb_tolower
+   1.00   stb_hash, stb_intcmp
+          stb_file, stb_stringfile, stb_fgets
+          stb_prefix, stb_strlower, stb_strtok
+          stb_image
+          (stb_array), (stb_arena)
+
+Parenthesized items have since been removed.
+*/
+
+#ifndef STB__INCLUDE_STB_H
+#define STB__INCLUDE_STB_H
+
+#define STB_VERSION  1
+
+#ifdef STB_INTROSPECT
+   #define STB_DEFINE
+#endif
+
+#ifdef STB_DEFINE_THREADS
+   #ifndef STB_DEFINE
+   #define STB_DEFINE
+   #endif
+   #ifndef STB_THREADS
+   #define STB_THREADS
+   #endif
+#endif
+
+#include <stdlib.h>     // stdlib could have min/max
+#include <stdio.h>      // need FILE
+#include <string.h>     // stb_define_hash needs memcpy/memset
+#include <time.h>       // stb_dirtree
+
+#ifdef STB_PERSONAL
+   typedef int Bool;
+   #define False 0
+   #define True 1
+#endif
+
+#ifdef STB_MALLOC_WRAPPER_PAGED
+   #define STB_MALLOC_WRAPPER_DEBUG
+#endif
+#ifdef STB_MALLOC_WRAPPER_DEBUG
+   #define STB_MALLOC_WRAPPER
+#endif
+#ifdef STB_MALLOC_WRAPPER_FASTMALLOC
+   #define STB_FASTMALLOC
+   #define STB_MALLOC_WRAPPER
+#endif
+
+#ifdef STB_FASTMALLOC
+   #ifndef _WIN32
+      #undef STB_FASTMALLOC
+   #endif
+#endif
+
+#ifdef STB_DEFINE
+   #include <assert.h>
+   #include <stdarg.h>
+   #include <stddef.h>
+   #include <ctype.h>
+   #include <math.h>
+   #ifndef _WIN32
+   #include <unistd.h>
+   #else
+   #include <io.h>      // _mktemp
+   #include <direct.h>  // _rmdir
+   #endif
+   #include <sys/types.h> // stat()/_stat()
+   #include <sys/stat.h>  // stat()/_stat()
+#endif
+
+#define stb_min(a,b)   ((a) < (b) ? (a) : (b))
+#define stb_max(a,b)   ((a) > (b) ? (a) : (b))
+
+#ifndef STB_ONLY
+   #if !defined(__cplusplus) && !defined(min) && !defined(max)
+     #define min(x,y) stb_min(x,y)
+     #define max(x,y) stb_max(x,y)
+   #endif
+
+   #ifndef M_PI
+     #define M_PI  3.14159265358979323846f
+   #endif
+
+   #ifndef TRUE
+     #define TRUE  1
+     #define FALSE 0
+   #endif
+
+   #ifndef deg2rad
+   #define deg2rad(a)  ((a)*(M_PI/180))
+   #endif
+   #ifndef rad2deg
+   #define rad2deg(a)  ((a)*(180/M_PI))
+   #endif
+   
+   #ifndef swap
+   #ifndef __cplusplus
+   #define swap(TYPE,a,b)  \
+               do { TYPE stb__t; stb__t = (a); (a) = (b); (b) = stb__t; } while (0)
+   #endif              
+   #endif
+    
+   typedef unsigned char  uint8 ;
+   typedef   signed char   int8 ;
+   typedef unsigned short uint16;
+   typedef   signed short  int16;
+  #if defined(STB_USE_LONG_FOR_32_BIT_INT) || defined(STB_LONG32)
+   typedef unsigned long  uint32;
+   typedef   signed long   int32;
+  #else
+   typedef unsigned int   uint32;
+   typedef   signed int    int32;
+  #endif
+
+   typedef unsigned char  uchar ;
+   typedef unsigned short ushort;
+   typedef unsigned int   uint  ;
+   typedef unsigned long  ulong ;
+
+   // produce compile errors if the sizes aren't right
+   typedef char stb__testsize16[sizeof(int16)==2];
+   typedef char stb__testsize32[sizeof(int32)==4];
+#endif
+
+#ifndef STB_TRUE
+  #define STB_TRUE 1
+  #define STB_FALSE 0
+#endif
+
+// if we're STB_ONLY, can't rely on uint32 or even uint, so all the
+// variables we'll use herein need typenames prefixed with 'stb':
+typedef unsigned char stb_uchar;
+typedef unsigned char stb_uint8;
+typedef unsigned int  stb_uint;
+typedef unsigned short stb_uint16;
+typedef          short stb_int16;
+typedef   signed char  stb_int8;
+#if defined(STB_USE_LONG_FOR_32_BIT_INT) || defined(STB_LONG32)
+  typedef unsigned long  stb_uint32;
+  typedef          long  stb_int32;
+#else
+  typedef unsigned int   stb_uint32;
+  typedef          int   stb_int32;
+#endif
+typedef char stb__testsize2_16[sizeof(stb_uint16)==2 ? 1 : -1];
+typedef char stb__testsize2_32[sizeof(stb_uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+  typedef unsigned __int64 stb_uint64;
+  typedef          __int64 stb_int64;
+  #define STB_IMM_UINT64(literalui64) (literalui64##ui64)
+  #define STB_IMM_INT64(literali64) (literali64##i64)
+#else
+  // ??
+  typedef unsigned long long stb_uint64;
+  typedef          long long stb_int64;
+  #define STB_IMM_UINT64(literalui64) (literalui64##ULL)
+  #define STB_IMM_INT64(literali64) (literali64##LL)
+#endif
+typedef char stb__testsize2_64[sizeof(stb_uint64)==8 ? 1 : -1];
+
+// add platform-specific ways of checking for sizeof(char*) == 8,
+// and make those define STB_PTR64
+#if defined(_WIN64) || defined(__x86_64__) || defined(__ia64__)
+  #define STB_PTR64
+#endif
+
+#ifdef STB_PTR64
+typedef char stb__testsize2_ptr[sizeof(char *) == 8];
+typedef stb_uint64 stb_uinta;
+typedef stb_int64  stb_inta;
+#else
+typedef char stb__testsize2_ptr[sizeof(char *) == 4];
+typedef stb_uint32 stb_uinta;
+typedef stb_int32  stb_inta;
+#endif
+typedef char stb__testsize2_uinta[sizeof(stb_uinta)==sizeof(char*) ? 1 : -1];
+
+// if so, we should define an int type that is the pointer size. until then,
+// we'll have to make do with this (which is not the same at all!)
+
+typedef union
+{
+   unsigned int i;
+   void * p;
+} stb_uintptr;
+
+
+#ifdef __cplusplus
+   #define STB_EXTERN   extern "C"
+#else
+   #define STB_EXTERN   extern
+#endif
+
+// check for well-known debug defines
+#if defined(DEBUG) || defined(_DEBUG) || defined(DBG)
+   #ifndef NDEBUG
+      #define STB_DEBUG
+   #endif
+#endif
+
+#ifdef STB_DEBUG
+   #include <assert.h>
+#endif
+
+
+STB_EXTERN void stb_wrapper_malloc(void *newp, int sz, char *file, int line);
+STB_EXTERN void stb_wrapper_free(void *oldp, char *file, int line);
+STB_EXTERN void stb_wrapper_realloc(void *oldp, void *newp, int sz, char *file, int line);
+STB_EXTERN void stb_wrapper_calloc(size_t num, size_t sz, char *file, int line);
+STB_EXTERN void stb_wrapper_listall(void (*func)(void *ptr, int sz, char *file, int line));
+STB_EXTERN void stb_wrapper_dump(char *filename);
+STB_EXTERN int stb_wrapper_allocsize(void *oldp);
+STB_EXTERN void stb_wrapper_check(void *oldp);
+
+#ifdef STB_DEFINE
+// this is a special function used inside malloc wrapper
+// to do allocations that aren't tracked (to avoid
+// reentrancy). Of course if someone _else_ wraps realloc,
+// this breaks, but if they're doing that AND the malloc
+// wrapper they need to explicitly check for reentrancy.
+//
+// only define realloc_raw() and we do realloc(NULL,sz)
+// for malloc() and realloc(p,0) for free().
+static void * stb__realloc_raw(void *p, int sz)
+{
+   if (p == NULL) return malloc(sz);
+   if (sz == 0)   { free(p); return NULL; }
+   return realloc(p,sz);
+}
+#endif
+
+#ifdef _WIN32
+STB_EXTERN void * stb_smalloc(size_t sz);
+STB_EXTERN void   stb_sfree(void *p);
+STB_EXTERN void * stb_srealloc(void *p, size_t sz);
+STB_EXTERN void * stb_scalloc(size_t n, size_t sz);
+STB_EXTERN char * stb_sstrdup(char *s);
+#endif
+
+#ifdef STB_FASTMALLOC
+#define malloc  stb_smalloc
+#define free    stb_sfree
+#define realloc stb_srealloc
+#define strdup  stb_sstrdup
+#define calloc  stb_scalloc
+#endif
+
+#ifndef STB_MALLOC_ALLCHECK
+   #define stb__check(p)  1
+#else
+   #ifndef STB_MALLOC_WRAPPER
+      #error STB_MALLOC_ALLCHECK requires STB_MALLOC_WRAPPER
+   #else
+      #define stb__check(p) stb_mcheck(p)
+   #endif
+#endif
+
+#ifdef STB_MALLOC_WRAPPER
+   STB_EXTERN void * stb__malloc(int, char *, int);
+   STB_EXTERN void * stb__realloc(void *, int, char *, int);
+   STB_EXTERN void * stb__calloc(size_t n, size_t s, char *, int);
+   STB_EXTERN void   stb__free(void *, char *file, int);
+   STB_EXTERN char * stb__strdup(char *s, char *file, int);
+   STB_EXTERN void   stb_malloc_checkall(void);
+   STB_EXTERN void   stb_malloc_check_counter(int init_delay, int rep_delay);
+   #ifndef STB_MALLOC_WRAPPER_DEBUG
+      #define stb_mcheck(p) 1
+   #else
+      STB_EXTERN int   stb_mcheck(void *);
+   #endif
+
+
+   #ifdef STB_DEFINE
+
+   #ifdef STB_MALLOC_WRAPPER_DEBUG
+      #define STB__PAD   32
+      #define STB__BIAS  16
+      #define STB__SIG   0x51b01234
+      #define STB__FIXSIZE(sz)  (((sz+3) & ~3) + STB__PAD)
+      #define STB__ptr(x,y)   ((char *) (x) + (y))
+   #else
+      #define STB__ptr(x,y)   (x)
+      #define STB__FIXSIZE(sz)  (sz)
+   #endif
+
+   #ifdef STB_MALLOC_WRAPPER_DEBUG
+   int stb_mcheck(void *p)
+   {
+      unsigned int sz;
+      if (p == NULL) return 1;
+      p = ((char *) p) - STB__BIAS;
+      sz = * (unsigned int *) p;
+      assert(* (unsigned int *) STB__ptr(p,4) == STB__SIG);
+      assert(* (unsigned int *) STB__ptr(p,8) == STB__SIG);
+      assert(* (unsigned int *) STB__ptr(p,12) == STB__SIG);
+      assert(* (unsigned int *) STB__ptr(p,sz-4) == STB__SIG+1);
+      assert(* (unsigned int *) STB__ptr(p,sz-8) == STB__SIG+1);
+      assert(* (unsigned int *) STB__ptr(p,sz-12) == STB__SIG+1);
+      assert(* (unsigned int *) STB__ptr(p,sz-16) == STB__SIG+1);
+      stb_wrapper_check(STB__ptr(p, STB__BIAS));
+      return 1;
+   }
+
+   static void stb__check2(void *p, int sz, char *file, int line)
+   {
+      stb_mcheck(p);
+   }
+
+   void stb_malloc_checkall(void)
+   {
+      stb_wrapper_listall(stb__check2);
+   }
+   #else
+   void stb_malloc_checkall(void) { }
+   #endif
+
+   static int stb__malloc_wait=(1 << 30), stb__malloc_next_wait = (1 << 30), stb__malloc_iter;
+   void stb_malloc_check_counter(int init_delay, int rep_delay)
+   {
+      stb__malloc_wait = init_delay;
+      stb__malloc_next_wait = rep_delay;
+   }
+
+   void stb_mcheck_all(void)
+   {
+      #ifdef STB_MALLOC_WRAPPER_DEBUG
+      ++stb__malloc_iter;
+      if (--stb__malloc_wait <= 0) {
+         stb_malloc_checkall();
+         stb__malloc_wait = stb__malloc_next_wait;
+      }
+      #endif
+   }
+
+   #ifdef STB_MALLOC_WRAPPER_PAGED
+   #define STB__WINDOWS_PAGE (1 << 12)
+   #ifndef _WINDOWS_
+   STB_EXTERN __declspec(dllimport) void * __stdcall VirtualAlloc(void *p, unsigned long size, unsigned long type, unsigned long protect);
+   STB_EXTERN __declspec(dllimport) int   __stdcall VirtualFree(void *p, unsigned long size, unsigned long freetype);
+   #endif
+   #endif
+
+   static void *stb__malloc_final(int sz)
+   {
+      #ifdef STB_MALLOC_WRAPPER_PAGED
+      int aligned = (sz + STB__WINDOWS_PAGE - 1) & ~(STB__WINDOWS_PAGE-1);
+      char *p = VirtualAlloc(NULL, aligned + STB__WINDOWS_PAGE, 0x2000, 0x04); // RESERVE, READWRITE
+      if (p == NULL) return p;
+      VirtualAlloc(p, aligned,   0x1000, 0x04); // COMMIT, READWRITE
+      return p;
+      #else
+      return malloc(sz);
+      #endif
+   }
+
+   static void stb__free_final(void *p)
+   {
+      #ifdef STB_MALLOC_WRAPPER_PAGED
+      VirtualFree(p, 0, 0x8000); // RELEASE
+      #else
+      free(p);
+      #endif
+   }
+
+   int stb__malloc_failure;
+   static void *stb__realloc_final(void *p, int sz, int old_sz)
+   {
+      #ifdef STB_MALLOC_WRAPPER_PAGED
+      void *q = stb__malloc_final(sz);
+      if (q == NULL)
+          return ++stb__malloc_failure, q;
+      // @TODO: deal with p being smaller!
+      memcpy(q, p, sz < old_sz ? sz : old_sz);
+      stb__free_final(p);
+      return q;
+      #else
+      return realloc(p,sz);
+      #endif
+   }
+
+   void stb__free(void *p, char *file, int line)
+   {
+      stb_mcheck_all();
+      if (!p) return;
+      #ifdef STB_MALLOC_WRAPPER_DEBUG
+      stb_mcheck(p);
+      #endif
+      stb_wrapper_free(p,file,line);
+      #ifdef STB_MALLOC_WRAPPER_DEBUG
+         p = STB__ptr(p,-STB__BIAS);
+         * (unsigned int *) STB__ptr(p,0) = 0xdeadbeef;
+         * (unsigned int *) STB__ptr(p,4) = 0xdeadbeef;
+         * (unsigned int *) STB__ptr(p,8) = 0xdeadbeef;
+         * (unsigned int *) STB__ptr(p,12) = 0xdeadbeef;
+      #endif
+      stb__free_final(p);
+   }
+
+   void * stb__malloc(int sz, char *file, int line)
+   {
+      void *p;
+      stb_mcheck_all();
+      if (sz == 0) return NULL;
+      p = stb__malloc_final(STB__FIXSIZE(sz));
+      if (p == NULL) p = stb__malloc_final(STB__FIXSIZE(sz));
+      if (p == NULL) p = stb__malloc_final(STB__FIXSIZE(sz));
+      if (p == NULL) {
+         ++stb__malloc_failure;
+         #ifdef STB_MALLOC_WRAPPER_DEBUG
+         stb_malloc_checkall();
+         #endif
+         return p;
+      }
+      #ifdef STB_MALLOC_WRAPPER_DEBUG
+      * (int *) STB__ptr(p,0) = STB__FIXSIZE(sz);
+      * (unsigned int *) STB__ptr(p,4) = STB__SIG;
+      * (unsigned int *) STB__ptr(p,8) = STB__SIG;
+      * (unsigned int *) STB__ptr(p,12) = STB__SIG;
+      * (unsigned int *) STB__ptr(p,STB__FIXSIZE(sz)-4) = STB__SIG+1;
+      * (unsigned int *) STB__ptr(p,STB__FIXSIZE(sz)-8) = STB__SIG+1;
+      * (unsigned int *) STB__ptr(p,STB__FIXSIZE(sz)-12) = STB__SIG+1;
+      * (unsigned int *) STB__ptr(p,STB__FIXSIZE(sz)-16) = STB__SIG+1;
+      p = STB__ptr(p, STB__BIAS);
+      #endif
+      stb_wrapper_malloc(p,sz,file,line);
+      return p;
+   }
+
+   void * stb__realloc(void *p, int sz, char *file, int line)
+   {
+      void *q;
+
+      stb_mcheck_all();
+      if (p == NULL) return stb__malloc(sz,file,line);
+      if (sz == 0  ) { stb__free(p,file,line); return NULL; }
+
+      #ifdef STB_MALLOC_WRAPPER_DEBUG
+         stb_mcheck(p);
+         p = STB__ptr(p,-STB__BIAS);
+      #endif
+      #ifdef STB_MALLOC_WRAPPER_PAGED
+      {
+         int n = stb_wrapper_allocsize(STB__ptr(p,STB__BIAS));
+         if (!n)
+            stb_wrapper_check(STB__ptr(p,STB__BIAS));
+         q = stb__realloc_final(p, STB__FIXSIZE(sz), STB__FIXSIZE(n));
+      }
+      #else
+      q = realloc(p, STB__FIXSIZE(sz));
+      #endif
+      if (q == NULL)
+         return ++stb__malloc_failure, q;
+      #ifdef STB_MALLOC_WRAPPER_DEBUG
+      * (int *) STB__ptr(q,0) = STB__FIXSIZE(sz);
+      * (unsigned int *) STB__ptr(q,4) = STB__SIG;
+      * (unsigned int *) STB__ptr(q,8) = STB__SIG;
+      * (unsigned int *) STB__ptr(q,12) = STB__SIG;
+      * (unsigned int *) STB__ptr(q,STB__FIXSIZE(sz)-4) = STB__SIG+1;
+      * (unsigned int *) STB__ptr(q,STB__FIXSIZE(sz)-8) = STB__SIG+1;
+      * (unsigned int *) STB__ptr(q,STB__FIXSIZE(sz)-12) = STB__SIG+1;
+      * (unsigned int *) STB__ptr(q,STB__FIXSIZE(sz)-16) = STB__SIG+1;
+
+      q = STB__ptr(q, STB__BIAS);
+      p = STB__ptr(p, STB__BIAS);
+      #endif
+      stb_wrapper_realloc(p,q,sz,file,line);
+      return q;
+   }
+
+   STB_EXTERN int stb_log2_ceil(unsigned int);
+   static void *stb__calloc(size_t n, size_t sz, char *file, int line)
+   {
+      void *q;
+      stb_mcheck_all();
+      if (n == 0 || sz == 0) return NULL;
+      if (stb_log2_ceil(n) + stb_log2_ceil(sz) >= 32) return NULL;
+      q = stb__malloc(n*sz, file, line);
+      if (q) memset(q, 0, n*sz);
+      return q;
+   }
+
+   char * stb__strdup(char *s, char *file, int line)
+   {
+      char *p;
+      stb_mcheck_all();
+      p = stb__malloc(strlen(s)+1, file, line);
+      if (!p) return p;
+      strcpy(p, s);
+      return p;
+   }
+   #endif // STB_DEFINE
+
+   #ifdef STB_FASTMALLOC
+   #undef malloc
+   #undef realloc
+   #undef free
+   #undef strdup
+   #undef calloc
+   #endif
+
+   // include everything that might define these, BEFORE making macros
+   #include <stdlib.h>
+   #include <string.h>
+   #include <malloc.h>
+
+   #define malloc(s)      stb__malloc (  s, __FILE__, __LINE__)
+   #define realloc(p,s)   stb__realloc(p,s, __FILE__, __LINE__)
+   #define calloc(n,s)    stb__calloc (n,s, __FILE__, __LINE__)
+   #define free(p)        stb__free   (p,   __FILE__, __LINE__)
+   #define strdup(p)      stb__strdup (p,   __FILE__, __LINE__)
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         Windows pretty display
+//
+
+STB_EXTERN void stbprint(const char *fmt, ...);
+STB_EXTERN char *stb_sprintf(const char *fmt, ...);
+STB_EXTERN char *stb_mprintf(const char *fmt, ...);
+
+#ifdef STB_DEFINE
+char *stb_sprintf(const char *fmt, ...)
+{
+   static char buffer[1024];
+   va_list v;
+   va_start(v,fmt);
+   #ifdef _WIN32
+   _vsnprintf(buffer, 1024, fmt, v);
+   #else
+   vsnprintf(buffer, 1024, fmt, v);
+   #endif
+   va_end(v);
+   buffer[1023] = 0;
+   return buffer;
+}
+
+char *stb_mprintf(const char *fmt, ...)
+{
+   static char buffer[1024];
+   va_list v;
+   va_start(v,fmt);
+   #ifdef _WIN32
+   _vsnprintf(buffer, 1024, fmt, v);
+   #else
+   vsnprintf(buffer, 1024, fmt, v);
+   #endif
+   va_end(v);
+   buffer[1023] = 0;
+   return strdup(buffer);
+}
+
+#ifdef _WIN32
+
+#ifndef _WINDOWS_
+STB_EXTERN __declspec(dllimport) int __stdcall WriteConsoleA(void *, const void *, unsigned int, unsigned int *, void *);
+STB_EXTERN __declspec(dllimport) void * __stdcall GetStdHandle(unsigned int);
+STB_EXTERN __declspec(dllimport) int __stdcall SetConsoleTextAttribute(void *, unsigned short);
+#endif
+
+static void stb__print_one(void *handle, char *s, int len)
+{
+   if (len)
+      if (WriteConsoleA(handle, s, len, NULL,NULL))
+         fwrite(s, 1, len, stdout); // if it fails, maybe redirected, so do normal
+}
+
+static void stb__print(char *s)
+{
+   void *handle = GetStdHandle((unsigned int) -11); // STD_OUTPUT_HANDLE
+   int pad=0; // number of padding characters to add
+
+   char *t = s;
+   while (*s) {
+      int lpad;
+      while (*s && *s != '{') {
+         if (pad) {
+            if (*s == '\r' || *s == '\n')
+               pad = 0;
+            else if (s[0] == ' ' && s[1] == ' ') {
+               stb__print_one(handle, t, s-t);
+               t = s;
+               while (pad) {
+                  stb__print_one(handle, t, 1);
+                  --pad;
+               }
+            }
+         }
+         ++s;
+      }
+      if (!*s) break;
+      stb__print_one(handle, t, s-t);
+      if (s[1] == '{') {
+         ++s;
+         continue;
+      }
+
+      if (s[1] == '#') {
+         t = s+3;
+         if (isxdigit(s[2]))
+            if (isdigit(s[2]))
+               SetConsoleTextAttribute(handle, s[2] - '0');
+            else
+               SetConsoleTextAttribute(handle, tolower(s[2]) - 'a' + 10);
+         else {
+            SetConsoleTextAttribute(handle, 0x0f);
+            t=s+2;
+         }
+      } else if (s[1] == '!') {
+         SetConsoleTextAttribute(handle, 0x0c);
+         t = s+2;
+      } else if (s[1] == '@') {
+         SetConsoleTextAttribute(handle, 0x09);
+         t = s+2;
+      } else if (s[1] == '$') {
+         SetConsoleTextAttribute(handle, 0x0a);
+         t = s+2;
+      } else {
+         SetConsoleTextAttribute(handle, 0x08); // 0,7,8,15 => shades of grey
+         t = s+1;
+      }
+
+      lpad = (t-s);
+      s = t;
+      while (*s && *s != '}') ++s;
+      if (!*s) break;
+      stb__print_one(handle, t, s-t);
+      if (s[1] == '}') {
+         t = s+2;
+      } else {
+         pad += 1+lpad;
+         t = s+1;
+      }
+      s=t;
+      SetConsoleTextAttribute(handle, 0x07);
+   }
+   stb__print_one(handle, t, s-t);
+   SetConsoleTextAttribute(handle, 0x07);
+}
+
+void stbprint(const char *fmt, ...)
+{
+   int res;
+   char buffer[1024];
+   char *tbuf = buffer;
+   va_list v;
+
+   va_start(v,fmt);
+   res = _vsnprintf(buffer, sizeof(buffer), fmt, v);
+   va_end(v);
+   buffer[sizeof(buffer)-1] = 0;
+
+   if (res < 0) {
+      tbuf = (char *) malloc(16384);
+      va_start(v,fmt);
+      res = _vsnprintf(tbuf,16384, fmt, v);
+      va_end(v);
+      tbuf[16383] = 0;
+   }
+
+   stb__print(tbuf);
+
+   if (tbuf != buffer)
+      free(tbuf);
+}
+
+#else  // _WIN32
+void stbprint(const char *fmt, ...)
+{
+   va_list v;
+   va_start(v,fmt);
+   vprintf(fmt,v);
+   va_end(v);
+}
+#endif // _WIN32
+#endif // STB_DEFINE
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         Windows UTF8 filename handling
+//
+// Windows stupidly treats 8-bit filenames as some dopey code page,
+// rather than utf-8. If we want to use utf8 filenames, we have to
+// convert them to WCHAR explicitly and call WCHAR versions of the
+// file functions. So, ok, we do.
+
+
+#ifdef _WIN32
+   #define stb__fopen(x,y)    _wfopen(stb__from_utf8(x), stb__from_utf8_alt(y))
+   #define stb__windows(x,y)  x
+#else
+   #define stb__fopen(x,y)    fopen(x,y)
+   #define stb__windows(x,y)  y
+#endif
+
+
+typedef unsigned short stb__wchar;
+
+STB_EXTERN stb__wchar * stb_from_utf8(stb__wchar *buffer, char *str, int n);
+STB_EXTERN char       * stb_to_utf8  (char *buffer, stb__wchar *str, int n);
+
+STB_EXTERN stb__wchar *stb__from_utf8(char *str);
+STB_EXTERN stb__wchar *stb__from_utf8_alt(char *str);
+STB_EXTERN char *stb__to_utf8(stb__wchar *str);
+
+
+#ifdef STB_DEFINE
+stb__wchar * stb_from_utf8(stb__wchar *buffer, char *ostr, int n)
+{
+   unsigned char *str = (unsigned char *) ostr;
+   stb_uint32 c;
+   int i=0;
+   --n;
+   while (*str) {
+      if (i >= n)
+         return NULL;
+      if (!(*str & 0x80))
+         buffer[i++] = *str++;
+      else if ((*str & 0xe0) == 0xc0) {
+         if (*str < 0xc2) return NULL;
+         c = (*str++ & 0x1f) << 6;
+         if ((*str & 0xc0) != 0x80) return NULL;
+         buffer[i++] = c + (*str++ & 0x3f);
+      } else if ((*str & 0xf0) == 0xe0) {
+         if (*str == 0xe0 && (str[1] < 0xa0 || str[1] > 0xbf)) return NULL;
+         if (*str == 0xed && str[1] > 0x9f) return NULL; // str[1] < 0x80 is checked below
+         c = (*str++ & 0x0f) << 12;
+         if ((*str & 0xc0) != 0x80) return NULL;
+         c += (*str++ & 0x3f) << 6;
+         if ((*str & 0xc0) != 0x80) return NULL;
+         buffer[i++] = c + (*str++ & 0x3f);
+      } else if ((*str & 0xf8) == 0xf0) {
+         if (*str > 0xf4) return NULL;
+         if (*str == 0xf0 && (str[1] < 0x90 || str[1] > 0xbf)) return NULL;
+         if (*str == 0xf4 && str[1] > 0x8f) return NULL; // str[1] < 0x80 is checked below
+         c = (*str++ & 0x07) << 18;
+         if ((*str & 0xc0) != 0x80) return NULL;
+         c += (*str++ & 0x3f) << 12;
+         if ((*str & 0xc0) != 0x80) return NULL;
+         c += (*str++ & 0x3f) << 6;
+         if ((*str & 0xc0) != 0x80) return NULL;
+         c += (*str++ & 0x3f);
+         // utf-8 encodings of values used in surrogate pairs are invalid
+         if ((c & 0xFFFFF800) == 0xD800) return NULL;
+         if (c >= 0x10000) {
+            c -= 0x10000;
+            if (i + 2 > n) return NULL;
+            buffer[i++] = 0xD800 | (0x3ff & (c >> 10));
+            buffer[i++] = 0xDC00 | (0x3ff & (c      ));
+         }
+      } else
+         return NULL;
+   }
+   buffer[i] = 0;
+   return buffer;
+}
+
+char * stb_to_utf8(char *buffer, stb__wchar *str, int n)
+{
+   int i=0;
+   --n;
+   while (*str) {
+      if (*str < 0x80) {
+         if (i+1 > n) return NULL;
+         buffer[i++] = (char) *str++;
+      } else if (*str < 0x800) {
+         if (i+2 > n) return NULL;
+         buffer[i++] = 0xc0 + (*str >> 6);
+         buffer[i++] = 0x80 + (*str & 0x3f);
+         str += 1;
+      } else if (*str >= 0xd800 && *str < 0xdc00) {
+         stb_uint32 c;
+         if (i+4 > n) return NULL;
+         c = ((str[0] - 0xd800) << 10) + ((str[1]) - 0xdc00) + 0x10000;
+         buffer[i++] = 0xf0 + (c >> 18);
+         buffer[i++] = 0x80 + ((c >> 12) & 0x3f);
+         buffer[i++] = 0x80 + ((c >>  6) & 0x3f);
+         buffer[i++] = 0x80 + ((c      ) & 0x3f);
+         str += 2;
+      } else if (*str >= 0xdc00 && *str < 0xe000) {
+         return NULL;
+      } else {
+         if (i+3 > n) return NULL;
+         buffer[i++] = 0xe0 + (*str >> 12);
+         buffer[i++] = 0x80 + ((*str >> 6) & 0x3f);
+         buffer[i++] = 0x80 + ((*str     ) & 0x3f);
+         str += 1;
+      }
+   }
+   buffer[i] = 0;
+   return buffer;
+}
+
+stb__wchar *stb__from_utf8(char *str)
+{
+   static stb__wchar buffer[4096];
+   return stb_from_utf8(buffer, str, 4096);
+}
+
+stb__wchar *stb__from_utf8_alt(char *str)
+{
+   static stb__wchar buffer[64];
+   return stb_from_utf8(buffer, str, 64);
+}
+
+char *stb__to_utf8(stb__wchar *str)
+{
+   static char buffer[4096];
+   return stb_to_utf8(buffer, str, 4096);
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         Miscellany
+//
+
+STB_EXTERN void stb_fatal(char *fmt, ...);
+STB_EXTERN void stb_(char *fmt, ...);
+STB_EXTERN void stb_append_to_file(char *file, char *fmt, ...);
+STB_EXTERN void stb_log(int active);
+STB_EXTERN void stb_log_fileline(int active);
+STB_EXTERN void stb_log_name(char *filename);
+
+STB_EXTERN void stb_swap(void *p, void *q, size_t sz);
+STB_EXTERN void *stb_copy(void *p, size_t sz);
+STB_EXTERN void stb_pointer_array_free(void *p, int len);
+STB_EXTERN void **stb_array_block_alloc(int count, int blocksize);
+
+#define stb_arrcount(x)   (sizeof(x)/sizeof((x)[0]))
+
+
+STB_EXTERN int  stb__record_fileline(char *f, int n);
+
+#ifdef STB_DEFINE
+
+static char *stb__file;
+static int   stb__line;
+
+int  stb__record_fileline(char *f, int n)
+{
+   stb__file = f;
+   stb__line = n;
+   return 0;
+}
+
+void stb_fatal(char *s, ...)
+{
+   va_list a;
+   if (stb__file)
+      fprintf(stderr, "[%s:%d] ", stb__file, stb__line);
+   va_start(a,s);
+   fputs("Fatal error: ", stderr);
+   vfprintf(stderr, s, a);
+   va_end(a);
+   fputs("\n", stderr);
+   #ifdef _WIN32
+   #ifdef STB_DEBUG
+   __asm int 3;   // trap to debugger!
+   #endif
+   #endif
+   exit(1);
+}
+
+static int stb__log_active=1, stb__log_fileline=1;
+
+void stb_log(int active)
+{
+   stb__log_active = active;
+}
+
+void stb_log_fileline(int active)
+{
+   stb__log_fileline = active;
+}
+
+#ifdef STB_NO_STB_STRINGS
+char *stb__log_filename = "temp.log";
+#else
+char *stb__log_filename = "stb.log";
+#endif
+
+void stb_log_name(char *s)
+{
+   stb__log_filename = s;
+}
+
+void stb_(char *s, ...)
+{
+   if (stb__log_active) {
+      FILE *f = fopen(stb__log_filename, "a");
+      if (f) {
+         va_list a;
+         if (stb__log_fileline && stb__file)
+            fprintf(f, "[%s:%4d] ", stb__file, stb__line);
+         va_start(a,s);
+         vfprintf(f, s, a);
+         va_end(a);
+         fputs("\n", f);
+         fclose(f);
+      }
+   }
+}
+
+void stb_append_to_file(char *filename, char *s, ...)
+{
+   FILE *f = fopen(filename, "a");
+   if (f) {
+      va_list a;
+      va_start(a,s);
+      vfprintf(f, s, a);
+      va_end(a);
+      fputs("\n", f);
+      fclose(f);
+   }
+}
+
+
+typedef struct { char d[4]; } stb__4;
+typedef struct { char d[8]; } stb__8;
+
+// optimize the small cases, though you shouldn't be calling this for those!
+void stb_swap(void *p, void *q, size_t sz)
+{
+   char buffer[256];
+   if (p == q) return;
+   if (sz == 4) {
+      stb__4 temp    = * ( stb__4 *) p;
+      * (stb__4 *) p = * ( stb__4 *) q;
+      * (stb__4 *) q = temp;
+      return;
+   } else if (sz == 8) {
+      stb__8 temp    = * ( stb__8 *) p;
+      * (stb__8 *) p = * ( stb__8 *) q;
+      * (stb__8 *) q = temp;
+      return;
+   }
+
+   while (sz > sizeof(buffer)) {
+      stb_swap(p, q, sizeof(buffer));
+      p = (char *) p + sizeof(buffer);
+      q = (char *) q + sizeof(buffer);
+      sz -= sizeof(buffer);
+   }
+
+   memcpy(buffer, p     , sz);
+   memcpy(p     , q     , sz);
+   memcpy(q     , buffer, sz);
+}
+
+void *stb_copy(void *p, size_t sz)
+{
+   void *q = malloc(sz);
+   memcpy(q, p, sz);
+   return q;
+}
+
+void stb_pointer_array_free(void *q, int len)
+{
+   void **p = (void **) q;
+   int i;
+   for (i=0; i < len; ++i)
+      free(p[i]);
+}
+
+void **stb_array_block_alloc(int count, int blocksize)
+{
+   int i;
+   char *p = (char *) malloc(sizeof(void *) * count + count * blocksize);
+   void **q;
+   if (p == NULL) return NULL;
+   q = (void **) p;
+   p += sizeof(void *) * count;
+   for (i=0; i < count; ++i)
+      q[i] = p + i * blocksize;
+   return q;
+}
+#endif
+
+#ifdef STB_DEBUG
+   // tricky hack to allow recording FILE,LINE even in varargs functions
+   #define STB__RECORD_FILE(x)  (stb__record_fileline(__FILE__, __LINE__),(x))
+   #define stb_log              STB__RECORD_FILE(stb_log)
+   #define stb_                 STB__RECORD_FILE(stb_)
+   #ifndef STB_FATAL_CLEAN
+   #define stb_fatal            STB__RECORD_FILE(stb_fatal)
+   #endif
+   #define STB__DEBUG(x)        x
+#else
+   #define STB__DEBUG(x)
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         stb_temp
+//
+
+#define stb_temp(block, sz)     stb__temp(block, sizeof(block), (sz))
+
+STB_EXTERN void * stb__temp(void *b, int b_sz, int want_sz);
+STB_EXTERN void   stb_tempfree(void *block, void *ptr);
+
+#ifdef STB_DEFINE
+
+void * stb__temp(void *b, int b_sz, int want_sz)
+{
+   if (b_sz >= want_sz)
+      return b;
+   else
+      return malloc(want_sz);
+}
+
+void   stb_tempfree(void *b, void *p)
+{
+   if (p != b)
+      free(p);
+}
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                      math/sampling operations
+//
+
+
+#define stb_lerp(t,a,b)               ( (a) + (t) * (float) ((b)-(a)) )
+#define stb_unlerp(t,a,b)             ( ((t) - (a)) / (float) ((b) - (a)) )
+
+#define stb_clamp(x,xmin,xmax)  ((x) < (xmin) ? (xmin) : (x) > (xmax) ? (xmax) : (x))
+
+STB_EXTERN void stb_newell_normal(float *normal, int num_vert, float **vert, int normalize);
+STB_EXTERN int stb_box_face_vertex_axis_side(int face_number, int vertex_number, int axis);
+STB_EXTERN void stb_linear_controller(float *curpos, float target_pos, float acc, float deacc, float dt);
+
+STB_EXTERN int stb_float_eq(float x, float y, float delta, int max_ulps);
+STB_EXTERN int stb_is_prime(unsigned int m);
+STB_EXTERN unsigned int stb_power_of_two_nearest_prime(int n);
+
+STB_EXTERN float stb_smoothstep(float t);
+STB_EXTERN float stb_cubic_bezier_1d(float t, float p0, float p1, float p2, float p3);
+
+STB_EXTERN double stb_linear_remap(double x, double a, double b,
+                                             double c, double d);
+
+#ifdef STB_DEFINE
+float stb_smoothstep(float t)
+{
+   return (3 - 2*t)*(t*t);
+}
+
+float stb_cubic_bezier_1d(float t, float p0, float p1, float p2, float p3)
+{
+   float it = 1-t;
+   return it*it*it*p0 + 3*it*it*t*p1 + 3*it*t*t*p2 + t*t*t*p3;
+}
+
+void stb_newell_normal(float *normal, int num_vert, float **vert, int normalize)
+{
+   int i,j;
+   float p;
+   normal[0] = normal[1] = normal[2] = 0;
+   for (i=num_vert-1,j=0; j < num_vert; i=j++) {
+      float *u = vert[i];
+      float *v = vert[j];
+      normal[0] += (u[1] - v[1]) * (u[2] + v[2]);
+      normal[1] += (u[2] - v[2]) * (u[0] + v[0]);
+      normal[2] += (u[0] - v[0]) * (u[1] + v[1]);
+   }
+   if (normalize) {
+      p = normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2];
+      p = (float) (1.0 / sqrt(p));
+      normal[0] *= p;
+      normal[1] *= p;
+      normal[2] *= p;
+   }
+}
+
+int stb_box_face_vertex_axis_side(int face_number, int vertex_number, int axis)
+{
+   static box_vertices[6][4][3] =
+   {
+      { { 1,1,1 }, { 1,0,1 }, { 1,0,0 }, { 1,1,0 } },
+      { { 0,0,0 }, { 0,0,1 }, { 0,1,1 }, { 0,1,0 } },
+      { { 0,0,0 }, { 0,1,0 }, { 1,1,0 }, { 1,0,0 } },
+      { { 0,0,0 }, { 1,0,0 }, { 1,0,1 }, { 0,0,1 } },
+      { { 1,1,1 }, { 0,1,1 }, { 0,0,1 }, { 1,0,1 } },
+      { { 1,1,1 }, { 1,1,0 }, { 0,1,0 }, { 0,1,1 } },
+   };
+   assert(face_number >= 0 && face_number < 6);
+   assert(vertex_number >= 0 && vertex_number < 4);
+   assert(axis >= 0 && axis < 3);
+   return box_vertices[face_number][vertex_number][axis];
+}
+
+void stb_linear_controller(float *curpos, float target_pos, float acc, float deacc, float dt)
+{
+   float sign = 1, p, cp = *curpos;
+   if (cp == target_pos) return;
+   if (target_pos < cp) {
+      target_pos = -target_pos;
+      cp = -cp;
+      sign = -1;
+   }
+   // first decelerate
+   if (cp < 0) {
+      p = cp + deacc * dt;
+      if (p > 0) {
+         p = 0;
+         dt = dt - cp / deacc;
+         if (dt < 0) dt = 0;
+      } else {
+         dt = 0;
+      }
+      cp = p;
+   }
+   // now accelerate
+   p = cp + acc*dt;
+   if (p > target_pos) p = target_pos;
+   *curpos = p * sign;
+   // @TODO: testing
+}
+
+float stb_quadratic_controller(float target_pos, float curpos, float maxvel, float maxacc, float dt, float *curvel)
+{
+   return 0; // @TODO
+}
+
+int stb_float_eq(float x, float y, float delta, int max_ulps)
+{
+   if (fabs(x-y) <= delta) return 1;
+   if (abs(*(int *)&x - *(int *)&y) <= max_ulps) return 1;
+   return 0;
+}
+
+int stb_is_prime(unsigned int m)
+{
+   unsigned int i,j;
+   if (m < 2) return 0;
+   if (m == 2) return 1;
+   if (!(m & 1)) return 0;
+   if (m % 3 == 0) return (m == 3);
+   for (i=5; (j=i*i), j <= m && j > i; i += 6) {
+      if (m %   i   == 0) return 0;
+      if (m % (i+2) == 0) return 0;
+   }
+   return 1;
+}
+
+unsigned int stb_power_of_two_nearest_prime(int n)
+{
+   static signed char tab[32] = { 0,0,0,0,1,0,-1,0,1,-1,-1,3,-1,0,-1,2,1,
+                                   0,2,0,-1,-4,-1,5,-1,18,-2,15,2,-1,2,0 };
+   if (!tab[0]) {
+      int i;
+      for (i=0; i < 32; ++i)
+         tab[i] = (1 << i) + 2*tab[i] - 1;
+      tab[1] = 2;
+      tab[0] = 1;
+   }
+   if (n >= 32) return 0xfffffffb;
+   return tab[n];
+}
+
+double stb_linear_remap(double x, double x_min, double x_max,
+                                  double out_min, double out_max)
+{
+   return stb_lerp(stb_unlerp(x,x_min,x_max),out_min,out_max);
+}
+#endif
+
+// create a macro so it's faster, but you can get at the function pointer
+#define stb_linear_remap(t,a,b,c,d)   stb_lerp(stb_unlerp(t,a,b),c,d)
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         bit operations
+//
+
+#define stb_big32(c)    (((c)[0]<<24) + (c)[1]*65536 + (c)[2]*256 + (c)[3])
+#define stb_little32(c) (((c)[3]<<24) + (c)[2]*65536 + (c)[1]*256 + (c)[0])
+#define stb_big16(c)    ((c)[0]*256 + (c)[1])
+#define stb_little16(c) ((c)[1]*256 + (c)[0])
+
+STB_EXTERN          int stb_bitcount(unsigned int a);
+STB_EXTERN unsigned int stb_bitreverse8(unsigned char n);
+STB_EXTERN unsigned int stb_bitreverse(unsigned int n);
+
+STB_EXTERN          int stb_is_pow2(unsigned int n);
+STB_EXTERN          int stb_log2_ceil(unsigned int n);
+STB_EXTERN          int stb_log2_floor(unsigned int n);
+
+STB_EXTERN          int stb_lowbit8(unsigned int n);
+STB_EXTERN          int stb_highbit8(unsigned int n);
+
+#ifdef STB_DEFINE
+int stb_bitcount(unsigned int a)
+{
+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
+   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+   a = (a + (a >> 8)); // max 16 per 8 bits
+   a = (a + (a >> 16)); // max 32 per 8 bits
+   return a & 0xff;
+}
+
+unsigned int stb_bitreverse8(unsigned char n)
+{
+   n = ((n & 0xAA) >> 1) + ((n & 0x55) << 1);
+   n = ((n & 0xCC) >> 2) + ((n & 0x33) << 2);
+   return (unsigned char) ((n >> 4) + (n << 4));
+}
+
+unsigned int stb_bitreverse(unsigned int n)
+{
+  n = ((n & 0xAAAAAAAA) >>  1) | ((n & 0x55555555) << 1);
+  n = ((n & 0xCCCCCCCC) >>  2) | ((n & 0x33333333) << 2);
+  n = ((n & 0xF0F0F0F0) >>  4) | ((n & 0x0F0F0F0F) << 4);
+  n = ((n & 0xFF00FF00) >>  8) | ((n & 0x00FF00FF) << 8);
+  return (n >> 16) | (n << 16);
+}
+
+int stb_is_pow2(unsigned int n)
+{
+   return (n & (n-1)) == 0;
+}
+
+// tricky use of 4-bit table to identify 5 bit positions (note the '-1')
+// 3-bit table would require another tree level; 5-bit table wouldn't save one
+#ifdef _WIN32
+#pragma warning(push)
+#pragma warning(disable: 4035)  // disable warning about no return value
+int stb_log2_floor(unsigned int n)
+{
+   __asm {
+      bsr eax,n
+      jnz done
+      mov eax,-1
+   }
+   done:;
+}
+#pragma warning(pop)
+#else
+int stb_log2_floor(unsigned int n)
+{
+   static signed char log2_4[16] = { -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3 };
+
+   // 2 compares if n < 16, 3 compares otherwise
+   if (n < (1U << 14))
+        if (n < (1U <<  4))        return     0 + log2_4[n      ];
+        else if (n < (1U <<  9))      return  5 + log2_4[n >>  5];
+             else                     return 10 + log2_4[n >> 10];
+   else if (n < (1U << 24))
+             if (n < (1U << 19))      return 15 + log2_4[n >> 15];
+             else                     return 20 + log2_4[n >> 20];
+        else if (n < (1U << 29))      return 25 + log2_4[n >> 25];
+             else                     return 30 + log2_4[n >> 30];
+}
+#endif
+
+// define ceil from floor
+int stb_log2_ceil(unsigned int n)
+{
+   if (stb_is_pow2(n))  return     stb_log2_floor(n);
+   else                 return 1 + stb_log2_floor(n);
+}
+
+int stb_highbit8(unsigned int n)
+{
+   return stb_log2_ceil(n&255);
+}
+
+int stb_lowbit8(unsigned int n)
+{
+   static signed char lowbit4[16] = { -1,0,1,0, 2,0,1,0, 3,0,1,0, 2,0,1,0 };
+   int k = lowbit4[n & 15];
+   if (k >= 0) return k;
+   k = lowbit4[(n >> 4) & 15];
+   if (k >= 0) return k+4;
+   return k;
+}
+#endif
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                            qsort Compare Routines
+//
+
+#ifdef _WIN32
+   #define stb_stricmp(a,b) stricmp(a,b)
+   #define stb_strnicmp(a,b,n) strnicmp(a,b,n)
+#else
+   #define stb_stricmp(a,b) strcasecmp(a,b)
+   #define stb_strnicmp(a,b,n) strncasecmp(a,b,n)
+#endif
+
+
+STB_EXTERN int (*stb_intcmp(int offset))(const void *a, const void *b);
+STB_EXTERN int (*stb_qsort_strcmp(int offset))(const void *a, const void *b);
+STB_EXTERN int (*stb_qsort_stricmp(int offset))(const void *a, const void *b);
+STB_EXTERN int (*stb_floatcmp(int offset))(const void *a, const void *b);
+STB_EXTERN int (*stb_doublecmp(int offset))(const void *a, const void *b);
+STB_EXTERN int (*stb_charcmp(int offset))(const void *a, const void *b);
+
+#ifdef STB_DEFINE
+static int stb__intcmpoffset, stb__charcmpoffset, stb__strcmpoffset;
+static int stb__floatcmpoffset, stb__doublecmpoffset;
+
+int stb__intcmp(const void *a, const void *b)
+{
+   const int p = *(const int *) ((const char *) a + stb__intcmpoffset);
+   const int q = *(const int *) ((const char *) b + stb__intcmpoffset);
+   return p < q ? -1 : p > q;
+}
+
+int stb__charcmp(const void *a, const void *b)
+{
+   const int p = *(const unsigned char *) ((const char *) a + stb__charcmpoffset);
+   const int q = *(const unsigned char *) ((const char *) b + stb__charcmpoffset);
+   return p < q ? -1 : p > q;
+}
+
+int stb__floatcmp(const void *a, const void *b)
+{
+   const float p = *(const float *) ((const char *) a + stb__floatcmpoffset);
+   const float q = *(const float *) ((const char *) b + stb__floatcmpoffset);
+   return p < q ? -1 : p > q;
+}
+
+int stb__doublecmp(const void *a, const void *b)
+{
+   const double p = *(const double *) ((const char *) a + stb__doublecmpoffset);
+   const double q = *(const double *) ((const char *) b + stb__doublecmpoffset);
+   return p < q ? -1 : p > q;
+}
+
+int stb__qsort_strcmp(const void *a, const void *b)
+{
+   const char *p = *(const char **) ((const char *) a + stb__strcmpoffset);
+   const char *q = *(const char **) ((const char *) b + stb__strcmpoffset);
+   return strcmp(p,q);
+}
+
+int stb__qsort_stricmp(const void *a, const void *b)
+{
+   const char *p = *(const char **) ((const char *) a + stb__strcmpoffset);
+   const char *q = *(const char **) ((const char *) b + stb__strcmpoffset);
+   return stb_stricmp(p,q);
+}
+
+int (*stb_intcmp(int offset))(const void *, const void *)
+{
+   stb__intcmpoffset = offset;
+   return &stb__intcmp;
+}
+
+int (*stb_charcmp(int offset))(const void *, const void *)
+{
+   stb__charcmpoffset = offset;
+   return &stb__charcmp;
+}
+
+int (*stb_qsort_strcmp(int offset))(const void *, const void *)
+{
+   stb__strcmpoffset = offset;
+   return &stb__qsort_strcmp;
+}
+
+int (*stb_qsort_stricmp(int offset))(const void *, const void *)
+{
+   stb__strcmpoffset = offset;
+   return &stb__qsort_stricmp;
+}
+
+int (*stb_floatcmp(int offset))(const void *, const void *)
+{
+   stb__floatcmpoffset = offset;
+   return &stb__floatcmp;
+}
+
+int (*stb_doublecmp(int offset))(const void *, const void *)
+{
+   stb__doublecmpoffset = offset;
+   return &stb__doublecmp;
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                           Binary Search Toolkit
+//
+
+typedef struct
+{
+   int minval, maxval, guess;
+   int mode, step;
+} stb_search;
+
+STB_EXTERN int stb_search_binary(stb_search *s, int minv, int maxv, int find_smallest);
+STB_EXTERN int stb_search_open(stb_search *s, int minv, int find_smallest);
+STB_EXTERN int stb_probe(stb_search *s, int compare, int *result); // return 0 when done
+
+#ifdef STB_DEFINE
+enum
+{
+   STB_probe_binary_smallest,
+   STB_probe_binary_largest,
+   STB_probe_open_smallest,
+   STB_probe_open_largest,
+};
+
+static int stb_probe_guess(stb_search *s, int *result)
+{
+   switch(s->mode) {
+      case STB_probe_binary_largest:
+         if (s->minval == s->maxval) {
+            *result = s->minval;
+            return 0;
+         }
+         assert(s->minval < s->maxval);
+         // if a < b, then a < p <= b
+         s->guess = s->minval + (((unsigned) s->maxval - s->minval + 1) >> 1);
+         break;
+
+      case STB_probe_binary_smallest:
+         if (s->minval == s->maxval) {
+            *result = s->minval;
+            return 0;
+         }
+         assert(s->minval < s->maxval);
+         // if a < b, then a <= p < b
+         s->guess = s->minval + (((unsigned) s->maxval - s->minval) >> 1);
+         break;
+      case STB_probe_open_smallest:
+      case STB_probe_open_largest:
+         s->guess = s->maxval;  // guess the current maxval
+         break;
+   }
+   *result = s->guess;
+   return 1;
+}
+
+int stb_probe(stb_search *s, int compare, int *result)
+{
+   switch(s->mode) {
+      case STB_probe_open_smallest:
+      case STB_probe_open_largest: {
+         if (compare <= 0) {
+            // then it lies within minval & maxval
+            if (s->mode == STB_probe_open_smallest)
+               s->mode = STB_probe_binary_smallest;
+            else
+               s->mode = STB_probe_binary_largest;
+         } else {
+            // otherwise, we need to probe larger
+            s->minval  = s->maxval + 1;
+            s->maxval  = s->minval + s->step;
+            s->step   += s->step;
+         }
+         break;
+      }
+      case STB_probe_binary_smallest: {
+         // if compare < 0, then s->minval <= a <  p
+         // if compare = 0, then s->minval <= a <= p
+         // if compare > 0, then         p <  a <= s->maxval
+         if (compare <= 0)
+            s->maxval = s->guess;
+         else
+            s->minval = s->guess+1;
+         break;
+      }
+      case STB_probe_binary_largest: {
+         // if compare < 0, then s->minval <= a < p
+         // if compare = 0, then         p <= a <= s->maxval
+         // if compare > 0, then         p <  a <= s->maxval
+         if (compare < 0)
+            s->maxval = s->guess-1;
+         else
+            s->minval = s->guess;
+         break;
+      }
+   }
+   return stb_probe_guess(s, result);
+}
+
+int stb_search_binary(stb_search *s, int minv, int maxv, int find_smallest)
+{
+   int r;
+   if (maxv < minv) return minv-1;
+   s->minval = minv;
+   s->maxval = maxv;
+   s->mode = find_smallest ? STB_probe_binary_smallest : STB_probe_binary_largest;
+   stb_probe_guess(s, &r);
+   return r;
+}
+
+int stb_search_open(stb_search *s, int minv, int find_smallest)
+{
+   int r;
+   s->step   = 4;
+   s->minval = minv;
+   s->maxval = minv+s->step;
+   s->mode = find_smallest ? STB_probe_open_smallest : STB_probe_open_largest;
+   stb_probe_guess(s, &r);
+   return r;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                           String Processing
+//
+
+#define stb_prefixi(s,t)  (0==stb_strnicmp((s),(t),strlen(t)))
+
+enum stb_splitpath_flag
+{
+   STB_PATH = 1,
+   STB_FILE = 2,
+   STB_EXT  = 4,
+   STB_PATH_FILE = STB_PATH + STB_FILE,
+   STB_FILE_EXT  = STB_FILE + STB_EXT,
+   STB_EXT_NO_PERIOD = 8,
+};
+
+STB_EXTERN char * stb_skipwhite(char *s);
+STB_EXTERN char * stb_trimwhite(char *s);
+STB_EXTERN char * stb_skipnewline(char *s);
+STB_EXTERN char * stb_strncpy(char *s, char *t, int n);
+STB_EXTERN char * stb_substr(char *t, int n);
+STB_EXTERN char * stb_duplower(char *s);
+STB_EXTERN void   stb_tolower (char *s);
+STB_EXTERN char * stb_strchr2 (char *s, char p1, char p2);
+STB_EXTERN char * stb_strrchr2(char *s, char p1, char p2);
+STB_EXTERN char * stb_strtok(char *output, char *src, char *delimit);
+STB_EXTERN char * stb_strtok_keep(char *output, char *src, char *delimit);
+STB_EXTERN char * stb_strtok_invert(char *output, char *src, char *allowed);
+STB_EXTERN char * stb_dupreplace(char *s, char *find, char *replace);
+STB_EXTERN void   stb_replaceinplace(char *s, char *find, char *replace);
+STB_EXTERN char * stb_splitpath(char *output, char *src, int flag);
+STB_EXTERN char * stb_splitpathdup(char *src, int flag);
+STB_EXTERN char * stb_replacedir(char *output, char *src, char *dir);
+STB_EXTERN char * stb_replaceext(char *output, char *src, char *ext);
+STB_EXTERN void   stb_fixpath(char *path);
+STB_EXTERN char * stb_shorten_path_readable(char *path, int max_len);
+STB_EXTERN int    stb_suffix (char *s, char *t);
+STB_EXTERN int    stb_suffixi(char *s, char *t);
+STB_EXTERN int    stb_prefix (char *s, char *t);
+STB_EXTERN char * stb_strichr(char *s, char t);
+STB_EXTERN char * stb_stristr(char *s, char *t);
+STB_EXTERN int    stb_prefix_count(char *s, char *t);
+STB_EXTERN char * stb_plural(int n);  // "s" or ""
+
+STB_EXTERN char **stb_tokens(char *src, char *delimit, int *count);
+STB_EXTERN char **stb_tokens_nested(char *src, char *delimit, int *count, char *nest_in, char *nest_out);
+STB_EXTERN char **stb_tokens_nested_empty(char *src, char *delimit, int *count, char *nest_in, char *nest_out);
+STB_EXTERN char **stb_tokens_allowempty(char *src, char *delimit, int *count);
+STB_EXTERN char **stb_tokens_stripwhite(char *src, char *delimit, int *count);
+STB_EXTERN char **stb_tokens_withdelim(char *src, char *delimit, int *count);
+STB_EXTERN char **stb_tokens_quoted(char *src, char *delimit, int *count);
+// with 'quoted', allow delimiters to appear inside quotation marks, and don't
+// strip whitespace inside them (and we delete the quotation marks unless they
+// appear back to back, in which case they're considered escaped)
+
+#ifdef STB_DEFINE
+
+char *stb_plural(int n)
+{
+   return n == 1 ? "" : "s";
+}
+
+int stb_prefix(char *s, char *t)
+{
+   while (*t)
+      if (*s++ != *t++)
+         return STB_FALSE;
+   return STB_TRUE;
+}
+
+int stb_prefix_count(char *s, char *t)
+{
+   int c=0;
+   while (*t) {
+      if (*s++ != *t++)
+         break;
+      ++c;
+   }
+   return c;
+}
+
+int stb_suffix(char *s, char *t)
+{
+   size_t n = strlen(s);
+   size_t m = strlen(t);
+   if (m <= n)
+      return 0 == strcmp(s+n-m, t);
+   else
+      return 0;
+}
+
+int stb_suffixi(char *s, char *t)
+{
+   size_t n = strlen(s);
+   size_t m = strlen(t);
+   if (m <= n)
+      return 0 == stb_stricmp(s+n-m, t);
+   else
+      return 0;
+}
+
+// originally I was using this table so that I could create known sentinel
+// values--e.g. change whitetable[0] to be true if I was scanning for whitespace,
+// and false if I was scanning for nonwhite. I don't appear to be using that
+// functionality anymore (I do for tokentable, though), so just replace it
+// with isspace()
+char *stb_skipwhite(char *s)
+{
+   while (isspace((unsigned char) *s)) ++s;
+   return s;
+}
+
+char *stb_skipnewline(char *s)
+{
+   if (s[0] == '\r' || s[0] == '\n') {
+      if (s[0]+s[1] == '\r' + '\n') ++s;
+      ++s;
+   }
+   return s;
+}
+
+char *stb_trimwhite(char *s)
+{
+   int i,n;
+   s = stb_skipwhite(s);
+   n = (int) strlen(s);
+   for (i=n-1; i >= 0; --i)
+      if (!isspace(s[i]))
+         break;
+   s[i+1] = 0;
+   return s;
+}
+
+char *stb_strncpy(char *s, char *t, int n)
+{
+   strncpy(s,t,n);
+   s[n-1] = 0;
+   return s;
+}
+
+char *stb_substr(char *t, int n)
+{
+   char *a;
+   int z = (int) strlen(t);
+   if (z < n) n = z;
+   a = (char *) malloc(n+1);
+   strncpy(a,t,n);
+   a[n] = 0;
+   return a;
+}
+
+char *stb_duplower(char *s)
+{
+   char *p = strdup(s), *q = p;
+   while (*q) {
+      *q = tolower(*q);
+      ++q;
+   }
+   return p;
+}
+
+void stb_tolower(char *s)
+{
+   while (*s) {
+      *s = tolower(*s);
+      ++s;
+   }
+}
+
+char *stb_strchr2(char *s, char x, char y)
+{
+   for(; *s; ++s)
+      if (*s == x || *s == y)
+         return s;
+   return NULL;
+}
+
+char *stb_strrchr2(char *s, char x, char y)
+{
+   char *r = NULL;
+   for(; *s; ++s)
+      if (*s == x || *s == y)
+         r = s;
+   return r;
+}
+
+char *stb_strichr(char *s, char t)
+{
+   if (tolower(t) == toupper(t))
+      return strchr(s,t);
+   return stb_strchr2(s, (char) tolower(t), (char) toupper(t));
+}
+
+char *stb_stristr(char *s, char *t)
+{
+   size_t n = strlen(t);
+   char *z;
+   if (n==0) return s;
+   while ((z = stb_strichr(s, *t)) != NULL) {
+      if (0==stb_strnicmp(z, t, n))
+         return z;
+      s = z+1;
+   }
+   return NULL;
+}
+
+static char *stb_strtok_raw(char *output, char *src, char *delimit, int keep, int invert)
+{
+   if (invert) {
+      while (*src && strchr(delimit, *src) != NULL) {
+         *output++ = *src++;
+      }
+   } else {
+      while (*src && strchr(delimit, *src) == NULL) {
+         *output++ = *src++;
+      }
+   }
+   *output = 0;
+   if (keep)
+      return src;
+   else
+      return *src ? src+1 : src;
+}
+
+char *stb_strtok(char *output, char *src, char *delimit)
+{
+   return stb_strtok_raw(output, src, delimit, 0, 0);
+}
+
+char *stb_strtok_keep(char *output, char *src, char *delimit)
+{
+   return stb_strtok_raw(output, src, delimit, 1, 0);
+}
+
+char *stb_strtok_invert(char *output, char *src, char *delimit)
+{
+   return stb_strtok_raw(output, src, delimit, 1,1);
+}
+
+static char **stb_tokens_raw(char *src_, char *delimit, int *count,
+                             int stripwhite, int allow_empty, char *start, char *end)
+{
+   int nested = 0;
+   unsigned char *src = (unsigned char *) src_;
+   static char stb_tokentable[256]; // rely on static initializion to 0
+   static char stable[256],etable[256];
+   char *out;
+   char **result;
+   int num=0;
+   unsigned char *s;
+
+   s = (unsigned char *) delimit; while (*s) stb_tokentable[*s++] = 1;
+   if (start) {
+      s = (unsigned char *) start;         while (*s) stable[*s++] = 1;
+      s = (unsigned char *) end;   if (s)  while (*s) stable[*s++] = 1;
+      s = (unsigned char *) end;   if (s)  while (*s) etable[*s++] = 1;
+   }
+   stable[0] = 1;
+
+   // two passes through: the first time, counting how many
+   s = (unsigned char *) src;
+   while (*s) {
+      // state: just found delimiter
+      // skip further delimiters
+      if (!allow_empty) {
+         stb_tokentable[0] = 0;
+         while (stb_tokentable[*s])
+            ++s;
+         if (!*s) break;
+      }
+      ++num;
+      // skip further non-delimiters
+      stb_tokentable[0] = 1;
+      if (stripwhite == 2) { // quoted strings
+         while (!stb_tokentable[*s]) {
+            if (*s != '"')
+               ++s;
+            else {
+               ++s;
+               if (*s == '"')
+                  ++s;   // "" -> ", not start a string
+               else {
+                  // begin a string
+                  while (*s) {
+                     if (s[0] == '"') {
+                        if (s[1] == '"') s += 2; // "" -> "
+                        else { ++s; break; } // terminating "
+                     } else
+                        ++s;
+                  }
+               }
+            }
+         }
+      } else 
+         while (nested || !stb_tokentable[*s]) {
+            if (stable[*s]) {
+               if (!*s) break;
+               if (end ? etable[*s] : nested)
+                  --nested;
+               else
+                  ++nested;
+            }
+            ++s;
+         }
+      if (allow_empty) {
+         if (*s) ++s;
+      }
+   }
+   // now num has the actual count... malloc our output structure
+   // need space for all the strings: strings won't be any longer than
+   // original input, since for every '\0' there's at least one delimiter
+   result = (char **) malloc(sizeof(*result) * (num+1) + (s-src+1));
+   if (result == NULL) return result;
+   out = (char *) (result + (num+1));
+   // second pass: copy out the data
+   s = (unsigned char *) src;
+   num = 0;
+   nested = 0;
+   while (*s) {
+      char *last_nonwhite;
+      // state: just found delimiter
+      // skip further delimiters
+      if (!allow_empty) {
+         stb_tokentable[0] = 0;
+         if (stripwhite)
+            while (stb_tokentable[*s] || isspace(*s))
+               ++s;
+         else
+            while (stb_tokentable[*s])
+               ++s;
+      } else if (stripwhite) {
+         while (isspace(*s)) ++s;
+      }
+      if (!*s) break;
+      // we're past any leading delimiters and whitespace
+      result[num] = out;
+      ++num;
+      // copy non-delimiters
+      stb_tokentable[0] = 1;
+      last_nonwhite = out-1;
+      if (stripwhite == 2) {
+         while (!stb_tokentable[*s]) {
+            if (*s != '"') {
+               if (!isspace(*s)) last_nonwhite = out;
+               *out++ = *s++;
+            } else {
+               ++s;
+               if (*s == '"') {
+                  if (!isspace(*s)) last_nonwhite = out;
+                  *out++ = *s++; // "" -> ", not start string
+               } else {
+                  // begin a quoted string
+                  while (*s) {
+                     if (s[0] == '"') {
+                        if (s[1] == '"') { *out++ = *s; s += 2; }
+                        else { ++s; break; } // terminating "
+                     } else
+                        *out++ = *s++;
+                  }
+                  last_nonwhite = out-1; // all in quotes counts as non-white
+               }
+            }
+         }
+      } else {
+         while (nested || !stb_tokentable[*s]) {
+            if (!isspace(*s)) last_nonwhite = out;
+            if (stable[*s]) {
+               if (!*s) break;
+               if (end ? etable[*s] : nested)
+                  --nested;
+               else
+                  ++nested;
+            }
+            *out++ = *s++;
+         }
+      }
+
+      if (stripwhite) // rewind to last non-whitespace char
+         out = last_nonwhite+1;
+      *out++ = '\0';
+
+      if (*s) ++s; // skip delimiter
+   }
+   s = (unsigned char *) delimit; while (*s) stb_tokentable[*s++] = 0;
+   if (start) {
+      s = (unsigned char *) start;         while (*s) stable[*s++] = 1;
+      s = (unsigned char *) end;   if (s)  while (*s) stable[*s++] = 1;
+      s = (unsigned char *) end;   if (s)  while (*s) etable[*s++] = 1;
+   }
+   if (count != NULL) *count = num;
+   result[num] = 0;
+   return result;
+}
+
+char **stb_tokens(char *src, char *delimit, int *count)
+{
+   return stb_tokens_raw(src,delimit,count,0,0,0,0);
+}
+
+char **stb_tokens_nested(char *src, char *delimit, int *count, char *nest_in, char *nest_out)
+{
+   return stb_tokens_raw(src,delimit,count,0,0,nest_in,nest_out);
+}
+
+char **stb_tokens_nested_empty(char *src, char *delimit, int *count, char *nest_in, char *nest_out)
+{
+   return stb_tokens_raw(src,delimit,count,0,1,nest_in,nest_out);
+}
+
+char **stb_tokens_allowempty(char *src, char *delimit, int *count)
+{
+   return stb_tokens_raw(src,delimit,count,0,1,0,0);
+}
+
+char **stb_tokens_stripwhite(char *src, char *delimit, int *count)
+{
+   return stb_tokens_raw(src,delimit,count,1,1,0,0);
+}
+
+char **stb_tokens_quoted(char *src, char *delimit, int *count)
+{
+   return stb_tokens_raw(src,delimit,count,2,1,0,0);
+}
+
+char *stb_dupreplace(char *src, char *find, char *replace)
+{
+   size_t len_find = strlen(find);
+   size_t len_replace = strlen(replace);
+   int count = 0;
+
+   char *s,*p,*q;
+
+   s = strstr(src, find);
+   if (s == NULL) return strdup(src);
+   do {
+      ++count;
+      s = strstr(s + len_find, find);
+   } while (s != NULL);
+
+   p = (char *)  malloc(strlen(src) + count * (len_replace - len_find) + 1);
+   if (p == NULL) return p;
+   q = p;
+   s = src;
+   for (;;) {
+      char *t = strstr(s, find);
+      if (t == NULL) {
+         strcpy(q,s);
+         assert(strlen(p) == strlen(src) + count*(len_replace-len_find));
+         return p;
+      }
+      memcpy(q, s, t-s);
+      q += t-s;
+      memcpy(q, replace, len_replace);
+      q += len_replace;
+      s = t + len_find;
+   }
+}
+
+void stb_replaceinplace(char *src, char *find, char *replace)
+{
+   size_t len_find = strlen(find);
+   size_t len_replace = strlen(replace);
+   int count = 0, delta;
+
+   char *s,*p,*q;
+
+   delta = len_replace - len_find;
+   assert(delta <= 0);
+   if (delta > 0) return;
+
+   p = strstr(src, find);
+   if (p == NULL) return;
+
+   s = q = p;
+   while (*s) {
+      memcpy(q, replace, len_replace);
+      p += len_find;
+      q += len_replace;
+      s = strstr(p, find);
+      if (s == NULL) s = p + strlen(p);
+      memmove(q, p, s-p);
+      q += s-p;
+      p = s;
+   }
+   *q = 0;
+}
+
+void stb_fixpath(char *path)
+{
+   for(; *path; ++path)
+      if (*path == '\\')
+         *path = '/';
+}
+
+void stb__add_section(char *buffer, char *data, int curlen, int newlen)
+{
+   if (newlen < curlen) {
+      int z1 = newlen >> 1, z2 = newlen-z1;
+      memcpy(buffer, data, z1-1);
+      buffer[z1-1] = '.';
+      buffer[z1-0] = '.';
+      memcpy(buffer+z1+1, data+curlen-z2+1, z2-1);
+   } else
+      memcpy(buffer, data, curlen);
+}
+
+char * stb_shorten_path_readable(char *path, int len)
+{
+   static char buffer[1024];
+   int n = strlen(path),n1,n2,r1,r2;
+   char *s;
+   if (n <= len) return path;
+   if (len > 1024) return path;
+   s = stb_strrchr2(path, '/', '\\');
+   if (s) {
+      n1 = s - path + 1;
+      n2 = n - n1;
+      ++s;
+   } else {
+      n1 = 0;
+      n2 = n;
+      s = path;
+   }
+   // now we need to reduce r1 and r2 so that they fit in len
+   if (n1 < len>>1) {
+      r1 = n1;
+      r2 = len - r1;
+   } else if (n2 < len >> 1) {
+      r2 = n2;
+      r1 = len - r2;
+   } else {
+      r1 = n1 * len / n;
+      r2 = n2 * len / n;
+      if (r1 < len>>2) r1 = len>>2, r2 = len-r1;
+      if (r2 < len>>2) r2 = len>>2, r1 = len-r2;
+   }
+   assert(r1 <= n1 && r2 <= n2);
+   if (n1)
+      stb__add_section(buffer, path, n1, r1);
+   stb__add_section(buffer+r1, s, n2, r2);
+   buffer[len] = 0;
+   return buffer;
+}
+
+static char *stb__splitpath_raw(char *buffer, char *path, int flag)
+{
+   int len=0,x,y, n = (int) strlen(path), f1,f2;
+   char *s = stb_strrchr2(path, '/', '\\');
+   char *t = strrchr(path, '.');
+   if (s && t && t < s) t = NULL;
+   if (s) ++s;
+
+   if (flag == STB_EXT_NO_PERIOD)
+      flag |= STB_EXT;
+
+   if (!(flag & (STB_PATH | STB_FILE | STB_EXT))) return NULL;
+
+   f1 = s == NULL ? 0 : s-path; // start of filename
+   f2 = t == NULL ? n : t-path; // just past end of filename
+
+   if (flag & STB_PATH) {
+      x = 0; if (f1 == 0 && flag == STB_PATH) len=2;
+   } else if (flag & STB_FILE) {
+      x = f1;
+   } else {
+      x = f2;
+      if (flag & STB_EXT_NO_PERIOD)
+         if (buffer[x] == '.')
+            ++x;
+   }
+
+   if (flag & STB_EXT)
+      y = n;
+   else if (flag & STB_FILE)
+      y = f2;
+   else
+      y = f1;
+
+   if (buffer == NULL) {
+      buffer = (char *) malloc(y-x + len + 1);
+      if (!buffer) return NULL;
+   }
+
+   if (len) { strcpy(buffer, "./"); return buffer; }
+   strncpy(buffer, path+x, y-x);
+   buffer[y-x] = 0;
+   return buffer;
+}
+
+char *stb_splitpath(char *output, char *src, int flag)
+{
+   return stb__splitpath_raw(output, src, flag);
+}
+
+char *stb_splitpathdup(char *src, int flag)
+{
+   return stb__splitpath_raw(NULL, src, flag);
+}
+
+char *stb_replacedir(char *output, char *src, char *dir)
+{
+   char buffer[4096];
+   stb_splitpath(buffer, src, STB_FILE | STB_EXT);
+   if (dir)
+      sprintf(output, "%s/%s", dir, buffer);
+   else
+      strcpy(output, buffer);
+   return output;
+}
+
+char *stb_replaceext(char *output, char *src, char *ext)
+{
+   char buffer[4096];
+   stb_splitpath(buffer, src, STB_PATH | STB_FILE);
+   if (ext)
+      sprintf(output, "%s.%s", buffer, ext[0] == '.' ? ext+1 : ext);
+   else
+      strcpy(output, buffer);
+   return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                   stb_alloc - hierarchical allocator
+//
+//                                     inspired by http://swapped.cc/halloc
+//
+//
+// When you alloc a given block through stb_alloc, you have these choices:
+//
+//       1. does it have a parent?
+//       2. can it have children?
+//       3. can it be freed directly?
+//       4. is it transferrable?
+//       5. what is its alignment?
+//
+// Here are interesting combinations of those:
+//
+//                              children   free    transfer     alignment
+//  arena                          Y         Y         N           n/a
+//  no-overhead, chunked           N         N         N         normal
+//  string pool alloc              N         N         N            1
+//  parent-ptr, chunked            Y         N         N         normal
+//  low-overhead, unchunked        N         Y         Y         normal
+//  general purpose alloc          Y         Y         Y         normal
+//
+// Unchunked allocations will probably return 16-aligned pointers. If
+// we 16-align the results, we have room for 4 pointers. For smaller
+// allocations that allow finer alignment, we can reduce the pointers.
+//
+// The strategy is that given a pointer, assuming it has a header (only
+// the no-overhead allocations have no header), we can determine the
+// type of the header fields, and the number of them, by stepping backwards
+// through memory and looking at the tags in the bottom bits.
+//
+// Implementation strategy:
+//     chunked allocations come from the middle of chunks, and can't
+//     be freed. thefore they do not need to be on a sibling chain.
+//     they may need child pointers if they have children.
+//
+// chunked, with-children
+//     void *parent;
+//
+// unchunked, no-children -- reduced storage
+//     void *next_sibling;
+//     void *prev_sibling_nextp;
+//
+// unchunked, general
+//     void *first_child;
+//     void *next_sibling;
+//     void *prev_sibling_nextp;
+//     void *chunks;
+//
+// so, if we code each of these fields with different bit patterns
+// (actually same one for next/prev/child), then we can identify which
+// each one is from the last field.
+
+STB_EXTERN void  stb_free(void *p);
+STB_EXTERN void *stb_malloc_global(size_t size);
+STB_EXTERN void *stb_malloc(void *context, size_t size);
+STB_EXTERN void *stb_malloc_nofree(void *context, size_t size);
+STB_EXTERN void *stb_malloc_leaf(void *context, size_t size);
+STB_EXTERN void *stb_malloc_raw(void *context, size_t size);
+STB_EXTERN void *stb_realloc(void *ptr, size_t newsize);
+
+STB_EXTERN void stb_reassign(void *new_context, void *ptr);
+STB_EXTERN void stb_malloc_validate(void *p, void *parent);
+
+extern int stb_alloc_chunk_size ;
+extern int stb_alloc_count_free ;
+extern int stb_alloc_count_alloc;
+extern int stb_alloc_alignment  ;
+
+#ifdef STB_DEFINE
+
+int stb_alloc_chunk_size  = 65536;
+int stb_alloc_count_free  = 0;
+int stb_alloc_count_alloc = 0;
+int stb_alloc_alignment   = -16;
+
+typedef struct stb__chunk
+{
+   struct stb__chunk *next;
+   int                data_left;
+   int                alloc;
+} stb__chunk;
+
+typedef struct
+{
+   void *  next;
+   void ** prevn;
+} stb__nochildren;
+
+typedef struct
+{
+   void ** prevn;
+   void *  child;
+   void *  next;
+   stb__chunk *chunks;
+} stb__alloc;
+
+typedef struct
+{
+   stb__alloc *parent;
+} stb__chunked;
+
+#define STB__PARENT          1
+#define STB__CHUNKS          2
+
+typedef enum
+{
+   STB__nochildren = 0,
+   STB__chunked    = STB__PARENT,
+   STB__alloc      = STB__CHUNKS,
+
+   STB__chunk_raw  = 4,
+} stb__alloc_type;
+
+// these functions set the bottom bits of a pointer efficiently
+#define STB__DECODE(x,v)  ((void *) ((char *) (x) - (v)))
+#define STB__ENCODE(x,v)  ((void *) ((char *) (x) + (v)))
+
+#define stb__parent(z)       (stb__alloc *) STB__DECODE((z)->parent, STB__PARENT)
+#define stb__chunks(z)       (stb__chunk *) STB__DECODE((z)->chunks, STB__CHUNKS)
+
+#define stb__setparent(z,p)  (z)->parent = (stb__alloc *) STB__ENCODE((p), STB__PARENT)
+#define stb__setchunks(z,c)  (z)->chunks = (stb__chunk *) STB__ENCODE((c), STB__CHUNKS)
+
+static stb__alloc stb__alloc_global =
+{
+   NULL,
+   NULL,
+   NULL,
+   (stb__chunk *) STB__ENCODE(NULL, STB__CHUNKS)
+};
+
+static stb__alloc_type stb__identify(void *p)
+{
+   void **q = (void **) p;
+   return (stb__alloc_type) ((stb_uinta) q[-1] & 3);
+}
+
+static void *** stb__prevn(void *p)
+{
+   if (stb__identify(p) == STB__alloc) {
+      stb__alloc      *s = (stb__alloc *) p - 1;
+      return &s->prevn;
+   } else {
+      stb__nochildren *s = (stb__nochildren *) p - 1;
+      return &s->prevn;
+   }
+}
+
+void stb_free(void *p)
+{
+   if (p == NULL) return;
+
+   // count frees so that unit tests can see what's happening
+   ++stb_alloc_count_free;
+
+   switch(stb__identify(p)) {
+      case STB__chunked:
+         // freeing a chunked-block with children does nothing;
+         // they only get freed when the parent does
+         // surely this is wrong, and it should free them immediately?
+         // otherwise how are they getting put on the right chain?
+         return;
+      case STB__nochildren: {
+         stb__nochildren *s = (stb__nochildren *) p - 1;
+         // unlink from sibling chain
+         *(s->prevn) = s->next;
+         if (s->next)
+            *stb__prevn(s->next) = s->prevn;
+         free(s);
+         return;
+      }
+      case STB__alloc: {
+         stb__alloc *s = (stb__alloc *) p - 1;
+         stb__chunk *c, *n;
+         void *q;
+
+         // unlink from sibling chain, if any
+         *(s->prevn) = s->next;
+         if (s->next)
+            *stb__prevn(s->next) = s->prevn;
+
+         // first free chunks
+         c = (stb__chunk *) stb__chunks(s);
+         while (c != NULL) {
+            n = c->next;
+            stb_alloc_count_free += c->alloc;
+            free(c);
+            c = n;
+         }
+
+         // validating
+         stb__setchunks(s,NULL);
+         s->prevn = NULL;
+         s->next = NULL;
+
+         // now free children
+         while ((q = s->child) != NULL) {
+            stb_free(q);
+         }
+
+         // now free self
+         free(s);
+         return;
+      }
+      default:
+         assert(0); /* NOTREACHED */
+   }
+}
+
+void stb_malloc_validate(void *p, void *parent)
+{
+   if (p == NULL) return;
+
+   switch(stb__identify(p)) {
+      case STB__chunked:
+         return;
+      case STB__nochildren: {
+         stb__nochildren *n = (stb__nochildren *) p - 1;
+         if (n->prevn)
+            assert(*n->prevn == p);
+         if (n->next) {
+            assert(*stb__prevn(n->next) == &n->next);
+            stb_malloc_validate(n, parent);
+         }
+         return;
+      }
+      case STB__alloc: {
+         stb__alloc *s = (stb__alloc *) p - 1;
+
+         if (s->prevn)
+            assert(*s->prevn == p);
+
+         if (s->child) {
+            assert(*stb__prevn(s->child) == &s->child);
+            stb_malloc_validate(s->child, p);
+         }
+
+         if (s->next) {
+            assert(*stb__prevn(s->next) == &s->next);
+            stb_malloc_validate(s->next, parent);
+         }
+         return;
+      }
+      default:
+         assert(0); /* NOTREACHED */
+   }
+}
+
+static void * stb__try_chunk(stb__chunk *c, int size, int align, int pre_align)
+{
+   char *memblock = (char *) (c+1), *q;
+   int  iq, start_offset;
+
+   // we going to allocate at the end of the chunk, not the start. confusing,
+   // but it means we don't need both a 'limit' and a 'cur', just a 'cur'.
+   // the block ends at: p + c->data_left
+   //   then we move back by size
+   start_offset = c->data_left - size;
+
+   // now we need to check the alignment of that
+   q = memblock + start_offset;
+   iq = (stb_inta) q;
+   assert(sizeof(q) == sizeof(iq));
+
+   // suppose align = 2
+   // then we need to retreat iq far enough that (iq & (2-1)) == 0
+   // to get (iq & (align-1)) = 0 requires subtracting (iq & (align-1))
+
+   start_offset -= iq & (align-1);
+   assert(((stb_uinta) (memblock+start_offset) & (align-1)) == 0);
+
+   // now, if that + pre_align works, go for it!
+   start_offset -= pre_align;
+
+   if (start_offset >= 0) {
+      c->data_left = start_offset;
+      return memblock + start_offset;
+   }
+
+   return NULL;
+}
+
+static void stb__sort_chunks(stb__alloc *src)
+{
+   // of the first two chunks, put the chunk with more data left in it first
+   stb__chunk *c = stb__chunks(src), *d;
+   if (c == NULL) return;
+   d = c->next;
+   if (d == NULL) return;
+   if (c->data_left > d->data_left) return;
+
+   c->next = d->next;
+   d->next = c;
+   stb__setchunks(src, d);
+}
+
+static void * stb__alloc_chunk(stb__alloc *src, int size, int align, int pre_align)
+{
+   void *p;
+   stb__chunk *c = stb__chunks(src);
+
+   if (c && size <= stb_alloc_chunk_size) {
+
+      p = stb__try_chunk(c, size, align, pre_align);
+      if (p) { ++c->alloc; return p; }
+
+      // try a second chunk to reduce wastage
+      if (c->next) {
+         p = stb__try_chunk(c->next, size, align, pre_align);
+         if (p) { ++c->alloc; return p; }
+   
+         // put the bigger chunk first, since the second will get buried
+         // the upshot of this is that, until it gets allocated from, chunk #2
+         // is always the largest remaining chunk. (could formalize
+         // this with a heap!)
+         stb__sort_chunks(src);
+         c = stb__chunks(src);
+      }
+   }
+
+   // allocate a new chunk
+   {
+      stb__chunk *n;
+
+      int chunk_size = stb_alloc_chunk_size;
+      // we're going to allocate a new chunk to put this in
+      if (size > chunk_size)
+         chunk_size = size;
+
+      assert(sizeof(*n) + pre_align <= 16);
+
+      // loop trying to allocate a large enough chunk
+      // the loop is because the alignment may cause problems if it's big...
+      // and we don't know what our chunk alignment is going to be
+      while (1) {
+         n = (stb__chunk *) malloc(16 + chunk_size);
+         if (n == NULL) return NULL;
+
+         n->data_left = chunk_size - sizeof(*n);
+
+         p = stb__try_chunk(n, size, align, pre_align);
+         if (p != NULL) {
+            n->next = c;
+            stb__setchunks(src, n);
+
+            // if we just used up the whole block immediately,
+            // move the following chunk up
+            n->alloc = 1;
+            if (size == chunk_size)
+               stb__sort_chunks(src);
+
+            return p;
+         }
+
+         free(n);
+         chunk_size += 16+align;
+      }
+   }
+}
+
+static stb__alloc * stb__get_context(void *context)
+{
+   if (context == NULL) {
+      return &stb__alloc_global;
+   } else {
+      int u = stb__identify(context);
+      // if context is chunked, grab parent
+      if (u == STB__chunked) {
+         stb__chunked *s = (stb__chunked *) context - 1;
+         return stb__parent(s);
+      } else {
+         return (stb__alloc *) context - 1;
+      }
+   }
+}
+
+static void stb__insert_alloc(stb__alloc *src, stb__alloc *s)
+{
+   s->prevn = &src->child;
+   s->next  = src->child;
+   src->child = s+1;
+   if (s->next)
+      *stb__prevn(s->next) = &s->next;
+}
+
+static void stb__insert_nochild(stb__alloc *src, stb__nochildren *s)
+{
+   s->prevn = &src->child;
+   s->next  = src->child;
+   src->child = s+1;
+   if (s->next)
+      *stb__prevn(s->next) = &s->next;
+}
+
+static void * malloc_base(void *context, size_t size, stb__alloc_type t, int align)
+{
+   void *p;
+
+   stb__alloc *src = stb__get_context(context);
+
+   if (align <= 0) {
+      // compute worst-case C packed alignment
+      // e.g. a 24-byte struct is 8-aligned
+      int align_proposed = 1 << stb_lowbit8(size);
+
+      if (align_proposed < 0)
+         align_proposed = 4;
+
+      if (align_proposed == 0) {
+         if (size == 0)
+            align_proposed = 1;
+         else
+            align_proposed = 256;
+      }
+
+      // a negative alignment means 'don't align any larger
+      // than this'; so -16 means we align 1,2,4,8, or 16
+
+      if (align < 0) {
+         if (align_proposed > -align)
+            align_proposed = -align;
+      }
+
+      align = align_proposed;
+   }
+
+   assert(stb_is_pow2(align));
+
+   // don't cause misalignment when allocating nochildren
+   if (t == STB__nochildren && align > 8)
+      t = STB__alloc;
+
+   switch (t) {
+      case STB__alloc: {
+         stb__alloc *s = (stb__alloc *) malloc(size + sizeof(*s));
+         if (s == NULL) return NULL;
+         p = s+1;
+         s->child = NULL;
+         stb__insert_alloc(src, s);
+
+         stb__setchunks(s,NULL);
+         break;
+      }
+
+      case STB__nochildren: {
+         stb__nochildren *s = (stb__nochildren *) malloc(size + sizeof(*s));
+         if (s == NULL) return NULL;
+         p = s+1;
+         stb__insert_nochild(src, s);
+         break;
+      }
+
+      case STB__chunk_raw: {
+         p = stb__alloc_chunk(src, size, align, 0);
+         if (p == NULL) return NULL;
+         break;
+      }
+
+      case STB__chunked: {
+         stb__chunked *s;
+         if (align < sizeof(stb_uintptr)) align = sizeof(stb_uintptr);
+         s = (stb__chunked *) stb__alloc_chunk(src, size, align, sizeof(*s));
+         if (s == NULL) return NULL;
+         stb__setparent(s, src);
+         p = s+1;
+         break;
+      }
+
+      default: assert(0); /* NOTREACHED */
+   }
+
+   ++stb_alloc_count_alloc;
+   return p;
+}
+
+void *stb_malloc_global(size_t size)
+{
+   return malloc_base(NULL, size, STB__alloc, stb_alloc_alignment);
+}
+
+void *stb_malloc(void *context, size_t size)
+{
+   return malloc_base(context, size, STB__alloc, stb_alloc_alignment);
+}
+
+void *stb_malloc_nofree(void *context, size_t size)
+{
+   return malloc_base(context, size, STB__chunked, stb_alloc_alignment);
+}
+
+void *stb_malloc_leaf(void *context, size_t size)
+{
+   return malloc_base(context, size, STB__nochildren, stb_alloc_alignment);
+}
+
+void *stb_malloc_raw(void *context, size_t size)
+{
+   return malloc_base(context, size, STB__chunk_raw, stb_alloc_alignment);
+}
+
+char *stb_malloc_string(void *context, size_t size)
+{
+   return (char *) malloc_base(context, size, STB__chunk_raw, 1);
+}
+
+void *stb_realloc(void *ptr, size_t newsize)
+{
+   stb__alloc_type t;
+
+   if (ptr == NULL) return stb_malloc(NULL, newsize);
+   if (newsize == 0) { stb_free(ptr); return NULL; }
+   
+   t = stb__identify(ptr);
+   assert(t == STB__alloc || t == STB__nochildren);
+
+   if (t == STB__alloc) {
+      stb__alloc *s = (stb__alloc *) ptr - 1;
+
+      s = (stb__alloc *) realloc(s, newsize + sizeof(*s));
+      if (s == NULL) return NULL;
+
+      ptr = s+1;
+
+      // update pointers
+      (*s->prevn) = ptr;
+      if (s->next)
+         *stb__prevn(s->next) = &s->next;
+
+      if (s->child)
+         *stb__prevn(s->child) = &s->child;
+
+      return ptr;
+   } else {
+      stb__nochildren *s = (stb__nochildren *) ptr - 1;
+
+      s = (stb__nochildren *) realloc(ptr, newsize + sizeof(s));
+      if (s == NULL) return NULL;
+
+      // update pointers
+      (*s->prevn) = s+1;
+      if (s->next)
+         *stb__prevn(s->next) = &s->next;
+
+      return s+1;
+   }
+}
+
+void *stb_realloc_c(void *context, void *ptr, size_t newsize)
+{
+   if (ptr == NULL) return stb_malloc(context, newsize);
+   if (newsize == 0) { stb_free(ptr); return NULL; }
+   // @TODO: verify you haven't changed contexts
+   return stb_realloc(ptr, newsize);
+}
+
+void stb_reassign(void *new_context, void *ptr)
+{
+   stb__alloc *src = stb__get_context(new_context);
+
+   stb__alloc_type t = stb__identify(ptr);
+   assert(t == STB__alloc || t == STB__nochildren);
+
+   if (t == STB__alloc) {
+      stb__alloc *s = (stb__alloc *) ptr - 1;
+
+      // unlink from old
+      *(s->prevn) = s->next;
+      if (s->next)
+         *stb__prevn(s->next) = s->prevn;
+
+      stb__insert_alloc(src, s);
+   } else {
+      stb__nochildren *s = (stb__nochildren *) ptr - 1;
+
+      // unlink from old
+      *(s->prevn) = s->next;
+      if (s->next)
+         *stb__prevn(s->next) = s->prevn;
+
+      stb__insert_nochild(src, s);
+   }
+}
+
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                                stb_arr
+//
+//  An stb_arr is directly useable as a pointer (use the actual type in your
+//  definition), but when it resizes, it returns a new pointer and you can't
+//  use the old one, so you have to be careful to copy-in-out as necessary.
+//
+//  Use a NULL pointer as a 0-length array.
+//
+//     float *my_array = NULL, *temp;
+//
+//     // add elements on the end one at a time
+//     stb_arr_push(my_array, 0.0f);
+//     stb_arr_push(my_array, 1.0f);
+//     stb_arr_push(my_array, 2.0f);
+//
+//     assert(my_array[1] == 2.0f);
+//
+//     // add an uninitialized element at the end, then assign it
+//     *stb_arr_add(my_array) = 3.0f;
+//
+//     // add three uninitialized elements at the end
+//     temp = stb_arr_addn(my_array,3);
+//     temp[0] = 4.0f;
+//     temp[1] = 5.0f;
+//     temp[2] = 6.0f;
+//
+//     assert(my_array[5] == 5.0f);
+//
+//     // remove the last one
+//     stb_arr_pop(my_array);
+//
+//     assert(stb_arr_len(my_array) == 6);
+
+
+#ifdef STB_MALLOC_WRAPPER
+  #define STB__PARAMS    , char *file, int line
+  #define STB__ARGS      ,       file,     line
+#else
+  #define STB__PARAMS
+  #define STB__ARGS
+#endif
+
+// calling this function allocates an empty stb_arr attached to p
+// (whereas NULL isn't attached to anything)
+STB_EXTERN void stb_arr_malloc(void **target, void *context);
+
+// call this function with a non-NULL value to have all successive
+// stbs that are created be attached to the associated parent. Note
+// that once a given stb_arr is non-empty, it stays attached to its
+// current parent, even if you call this function again.
+// it turns the previous value, so you can restore it
+STB_EXTERN void* stb_arr_malloc_parent(void *p);
+
+// simple functions written on top of other functions
+#define stb_arr_empty(a)       (  stb_arr_len(a) == 0 )
+#define stb_arr_add(a)         (  stb_arr_addn((a),1) )
+#define stb_arr_push(a,v)      ( *stb_arr_add(a)=(v)  )
+
+typedef struct
+{
+   int len, limit;
+   int stb_malloc;
+   unsigned int signature;
+} stb__arr;
+
+#define stb_arr_signature      0x51bada7b  // ends with 0123 in decimal
+
+// access the header block stored before the data
+#define stb_arrhead(a)         /*lint --e(826)*/ (((stb__arr *) (a)) - 1)
+#define stb_arrhead2(a)        /*lint --e(826)*/ (((stb__arr *) (a)) - 1)
+
+#ifdef STB_DEBUG
+#define stb_arr_check(a)       assert(!a || stb_arrhead(a)->signature == stb_arr_signature)
+#define stb_arr_check2(a)      assert(!a || stb_arrhead2(a)->signature == stb_arr_signature)
+#else
+#define stb_arr_check(a)       0
+#define stb_arr_check2(a)      0
+#endif
+
+// ARRAY LENGTH
+
+// get the array length; special case if pointer is NULL
+#define stb_arr_len(a)         (a ? stb_arrhead(a)->len : 0)
+#define stb_arr_len2(a)        ((stb__arr *) (a) ? stb_arrhead2(a)->len : 0)
+#define stb_arr_lastn(a)       (stb_arr_len(a)-1)
+
+// check whether a given index is valid -- tests 0 <= i < stb_arr_len(a) 
+#define stb_arr_valid(a,i)     (a ? (int) (i) < stb_arrhead(a)->len : 0)
+
+// change the array length so is is exactly N entries long, creating
+// uninitialized entries as needed
+#define stb_arr_setlen(a,n)  \
+            (stb__arr_setlen((void **) &(a), sizeof(a[0]), (n)))
+
+// change the array length so that N is a valid index (that is, so
+// it is at least N entries long), creating uninitialized entries as needed
+#define stb_arr_makevalid(a,n)  \
+            (stb_arr_len(a) < (n)+1 ? stb_arr_setlen(a,(n)+1),(a) : (a))
+
+// remove the last element of the array, returning it
+#define stb_arr_pop(a)         ((stb_arr_check(a), (a))[--stb_arrhead(a)->len])
+
+// access the last element in the array
+#define stb_arr_last(a)        ((stb_arr_check(a), (a))[stb_arr_len(a)-1])
+
+// is iterator at end of list?
+#define stb_arr_end(a,i)       ((i) >= &(a)[stb_arr_len(a)])
+
+// (internal) change the allocated length of the array
+#define stb_arr__grow(a,n)     (stb_arr_check(a), stb_arrhead(a)->len += (n))
+
+// add N new unitialized elements to the end of the array
+#define stb_arr__addn(a,n)     /*lint --e(826)*/ \
+                               ((stb_arr_len(a)+(n) > stb_arrcurmax(a))      \
+                                 ? (stb__arr_addlen((void **) &(a),sizeof(*a),(n)),0) \
+                                 : ((stb_arr__grow(a,n), 0)))
+
+// add N new unitialized elements to the end of the array, and return
+// a pointer to the first new one
+#define stb_arr_addn(a,n)      (stb_arr__addn((a),n),(a)+stb_arr_len(a)-(n))
+
+// add N new uninitialized elements starting at index 'i'
+#define stb_arr_insertn(a,i,n) (stb__arr_insertn((void **) &(a), sizeof(*a), i, n))
+
+// insert an element at i
+#define stb_arr_insert(a,i,v)  (stb__arr_insertn((void **) &(a), sizeof(*a), i, n), ((a)[i] = v))
+
+// delete N elements from the middle starting at index 'i'
+#define stb_arr_deleten(a,i,n) (stb__arr_deleten((void **) &(a), sizeof(*a), i, n))
+
+// delete the i'th element
+#define stb_arr_delete(a,i)   stb_arr_deleten(a,i,1)
+
+// delete the i'th element, swapping down from the end
+#define stb_arr_fastdelete(a,i)  \
+   (stb_swap(&a[i], &a[stb_arrhead(a)->len-1], sizeof(*a)), stb_arr_pop(a))
+
+
+// ARRAY STORAGE
+
+// get the array maximum storage; special case if NULL
+#define stb_arrcurmax(a)       (a ? stb_arrhead(a)->limit : 0)
+#define stb_arrcurmax2(a)      (a ? stb_arrhead2(a)->limit : 0)
+
+// set the maxlength of the array to n in anticipation of further growth
+#define stb_arr_setsize(a,n)   (stb_arr_check(a), stb__arr_setsize((void **) &(a),sizeof((a)[0]),n))
+
+// make sure maxlength is large enough for at least N new allocations
+#define stb_arr_atleast(a,n)   (stb_arr_len(a)+(n) > stb_arrcurmax(a)      \
+                                 ? stb_arr_setsize((a), (n)) : 0)
+
+// make a copy of a given array (copies contents via 'memcpy'!)
+#define stb_arr_copy(a)        stb__arr_copy(a, sizeof((a)[0]))
+
+// compute the storage needed to store all the elements of the array
+#define stb_arr_storage(a)     (stb_arr_len(a) * sizeof((a)[0]))
+
+#define stb_arr_for(v,arr)     for((v)=(arr); (v) < (arr)+stb_arr_len(arr); ++(v))
+
+// IMPLEMENTATION
+
+STB_EXTERN void stb_arr_free_(void **p);
+STB_EXTERN void *stb__arr_copy_(void *p, int elem_size);
+STB_EXTERN void stb__arr_setsize_(void **p, int size, int limit  STB__PARAMS);
+STB_EXTERN void stb__arr_setlen_(void **p, int size, int newlen  STB__PARAMS);
+STB_EXTERN void stb__arr_addlen_(void **p, int size, int addlen  STB__PARAMS);
+STB_EXTERN void stb__arr_deleten_(void **p, int size, int loc, int n  STB__PARAMS);
+STB_EXTERN void stb__arr_insertn_(void **p, int size, int loc, int n  STB__PARAMS);
+
+#define stb_arr_free(p)            stb_arr_free_((void **) &(p))
+#define stb__arr_copy              stb__arr_copy_
+
+#ifndef STB_MALLOC_WRAPPER
+  #define stb__arr_setsize         stb__arr_setsize_
+  #define stb__arr_setlen          stb__arr_setlen_
+  #define stb__arr_addlen          stb__arr_addlen_
+  #define stb__arr_deleten         stb__arr_deleten_
+  #define stb__arr_insertn         stb__arr_insertn_
+#else
+  #define stb__arr_addlen(p,s,n)    stb__arr_addlen_(p,s,n,__FILE__,__LINE__)
+  #define stb__arr_setlen(p,s,n)    stb__arr_setlen_(p,s,n,__FILE__,__LINE__)
+  #define stb__arr_setsize(p,s,n)   stb__arr_setsize_(p,s,n,__FILE__,__LINE__)
+  #define stb__arr_deleten(p,s,i,n) stb__arr_deleten_(p,s,i,n,__FILE__,__LINE__)
+  #define stb__arr_insertn(p,s,i,n) stb__arr_insertn_(p,s,i,n,__FILE__,__LINE__)
+#endif
+
+#ifdef STB_DEFINE
+static void *stb__arr_context;
+
+void *stb_arr_malloc_parent(void *p)
+{
+   void *q = stb__arr_context;
+   stb__arr_context = p;
+   return q;
+}
+
+void stb_arr_malloc(void **target, void *context)
+{
+   stb__arr *q = (stb__arr *) stb_malloc(context, sizeof(*q));
+   q->len = q->limit = 0;
+   q->stb_malloc = 1;
+   q->signature = stb_arr_signature;
+   *target = (void *) (q+1);
+}
+
+static void * stb__arr_malloc(int size)
+{
+   if (stb__arr_context)
+      return stb_malloc(stb__arr_context, size);
+   return malloc(size);
+}
+
+void * stb__arr_copy_(void *p, int elem_size)
+{
+   stb__arr *q;
+   if (p == NULL) return p;
+   q = (stb__arr *) stb__arr_malloc(sizeof(*q) + elem_size * stb_arrhead2(p)->limit);
+   stb_arr_check2(p);
+   memcpy(q, stb_arrhead2(p), sizeof(*q) + elem_size * stb_arrhead2(p)->len);
+   q->stb_malloc = !!stb__arr_context;
+   return q+1;
+}
+
+void stb_arr_free_(void **pp)
+{
+   void *p = *pp;
+   stb_arr_check2(p);
+   if (p) {
+      stb__arr *q = stb_arrhead2(p);
+      if (q->stb_malloc)
+         stb_free(q);
+      else
+         free(q);
+   }
+   *pp = NULL;
+}
+
+static void stb__arrsize_(void **pp, int size, int limit, int len  STB__PARAMS)
+{
+   void *p = *pp;
+   stb__arr *a;
+   stb_arr_check2(p);
+   if (p == NULL) {
+      if (len == 0 && size == 0) return;
+      a = (stb__arr *) stb__arr_malloc(sizeof(*a) + size*limit);
+      a->limit = limit;
+      a->len   = len;
+      a->stb_malloc = !!stb__arr_context;
+      a->signature = stb_arr_signature;
+   } else {
+      a = stb_arrhead2(p);
+      a->len = len;
+      if (a->limit < limit) {
+         void *p;
+         if (a->limit >= 4 && limit < a->limit * 2)
+            limit = a->limit * 2;
+         if (a->stb_malloc)
+            p = stb_realloc(a, sizeof(*a) + limit*size);
+         else
+            #ifdef STB_MALLOC_WRAPPER
+            p = stb__realloc(a, sizeof(*a) + limit*size, file, line);
+            #else
+            p = realloc(a, sizeof(*a) + limit*size);
+            #endif
+         if (p) {
+            a = (stb__arr *) p;
+            a->limit = limit;
+         } else {
+            // throw an error!
+         }
+      }
+   }
+   a->len   = stb_min(a->len, a->limit);
+   *pp = a+1;
+}
+
+void stb__arr_setsize_(void **pp, int size, int limit  STB__PARAMS)
+{
+   void *p = *pp;
+   stb_arr_check2(p);
+   stb__arrsize_(pp, size, limit, stb_arr_len2(p)  STB__ARGS);
+}
+
+void stb__arr_setlen_(void **pp, int size, int newlen  STB__PARAMS)
+{
+   void *p = *pp;
+   stb_arr_check2(p);
+   if (stb_arrcurmax2(p) < newlen || p == NULL) {
+      stb__arrsize_(pp, size, newlen, newlen  STB__ARGS);
+   } else {
+      stb_arrhead2(p)->len = newlen;
+   }
+}
+
+void stb__arr_addlen_(void **p, int size, int addlen  STB__PARAMS)
+{
+   stb__arr_setlen_(p, size, stb_arr_len2(*p) + addlen  STB__ARGS);
+}
+
+void stb__arr_insertn_(void **pp, int size, int i, int n  STB__PARAMS)
+{
+   void *p = *pp;
+   if (n) {
+      int z;
+
+      if (p == NULL) {
+         stb__arr_addlen_(pp, size, n  STB__ARGS);
+         return;
+      }
+
+      z = stb_arr_len2(p);
+      stb__arr_addlen_(&p, size, i  STB__ARGS);
+      memmove((char *) p + (i+n)*size, (char *) p + i*size, size * (z-i));
+   }
+   *pp = p;
+}
+
+void stb__arr_deleten_(void **pp, int size, int i, int n  STB__PARAMS)
+{
+   void *p = *pp;
+   if (n) {
+      memmove((char *) p + i*size, (char *) p + (i+n)*size, size * (stb_arr_len2(p)-i));
+      stb_arrhead2(p)->len -= n;
+   }
+   *pp = p;
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                               Hashing
+//
+//      typical use for this is to make a power-of-two hash table.
+//
+//      let N = size of table (2^n)
+//      let H = stb_hash(str)
+//      let S = stb_rehash(H) | 1
+//
+//      then hash probe sequence P(i) for i=0..N-1
+//         P(i) = (H + S*i) & (N-1)
+//
+//      the idea is that H has 32 bits of hash information, but the
+//      table has only, say, 2^20 entries so only uses 20 of the bits.
+//      then by rehashing the original H we get 2^12 different probe
+//      sequences for a given initial probe location. (So it's optimal
+//      for 64K tables and its optimality decreases past that.)
+//
+//      ok, so I've added something that generates _two separate_
+//      32-bit hashes simultaneously which should scale better to
+//      very large tables.
+
+
+STB_EXTERN unsigned int stb_hash(char *str);
+STB_EXTERN unsigned int stb_hashptr(void *p);
+STB_EXTERN unsigned int stb_hashlen(char *str, int len);
+STB_EXTERN unsigned int stb_rehash_improved(unsigned int v);
+STB_EXTERN unsigned int stb_hash_fast(void *p, int len);
+STB_EXTERN unsigned int stb_hash2(char *str, unsigned int *hash2_ptr);
+STB_EXTERN unsigned int stb_hash_number(unsigned int hash);
+
+#define stb_rehash(x)  ((x) + ((x) >> 6) + ((x) >> 19))
+
+#ifdef STB_DEFINE
+unsigned int stb_hash(char *str)
+{
+   unsigned int hash = 0;
+   while (*str)
+      hash = (hash << 7) + (hash >> 25) + *str++;
+   return hash + (hash >> 16);
+}
+
+unsigned int stb_hashlen(char *str, int len)
+{
+   unsigned int hash = 0;
+   while (len-- > 0 && *str)
+      hash = (hash << 7) + (hash >> 25) + *str++;
+   return hash + (hash >> 16);
+}
+
+unsigned int stb_hashptr(void *p)
+{
+   unsigned int x = (unsigned int) p;
+
+   // typically lacking in low bits and high bits
+   x = stb_rehash(x);
+   x += x << 16;
+
+   // pearson's shuffle
+   x ^= x << 3;
+   x += x >> 5;
+   x ^= x << 2;
+   x += x >> 15;
+   x ^= x << 10;
+   return stb_rehash(x);
+}
+
+unsigned int stb_rehash_improved(unsigned int v)
+{
+   return stb_hashptr((void *) v);
+}
+
+unsigned int stb_hash2(char *str, unsigned int *hash2_ptr)
+{
+   unsigned int hash1 = 0x3141592c;
+   unsigned int hash2 = 0x77f044ed;
+   while (*str) {
+      hash1 = (hash1 << 7) + (hash1 >> 25) + *str;
+      hash2 = (hash2 << 11) + (hash2 >> 21) + *str;
+      ++str;
+   }
+   *hash2_ptr = hash2 + (hash1 >> 16);
+   return       hash1 + (hash2 >> 16);
+}
+
+// Paul Hsieh hash
+#define stb__get16_slow(p) ((p)[0] + ((p)[1] << 8))
+#if defined(_MSC_VER)
+   #define stb__get16(p) (*((unsigned short *) (p)))
+#else
+   #define stb__get16(p) stb__get16_slow(p)
+#endif
+
+unsigned int stb_hash_fast(void *p, int len)
+{
+   unsigned char *q = (unsigned char *) p;
+   unsigned int hash = len;
+
+   if (len <= 0 || q == NULL) return 0;
+
+   /* Main loop */
+   if (((int) q & 1) == 0) {
+      for (;len > 3; len -= 4) {
+         unsigned int val;
+         hash +=  stb__get16(q);
+         val   = (stb__get16(q+2) << 11);
+         hash  = (hash << 16) ^ hash ^ val;
+         q    += 4;
+         hash += hash >> 11;
+      }
+   } else {
+      for (;len > 3; len -= 4) {
+         unsigned int val;
+         hash +=  stb__get16_slow(q);
+         val   = (stb__get16_slow(q+2) << 11);
+         hash  = (hash << 16) ^ hash ^ val;
+         q    += 4;
+         hash += hash >> 11;
+      }
+   }
+
+   /* Handle end cases */
+   switch (len) {
+      case 3: hash += stb__get16_slow(q);
+              hash ^= hash << 16;
+              hash ^= q[2] << 18;
+              hash += hash >> 11;
+              break;
+      case 2: hash += stb__get16_slow(q);
+              hash ^= hash << 11;
+              hash += hash >> 17;
+              break;
+      case 1: hash += q[0];
+              hash ^= hash << 10;
+              hash += hash >> 1;
+              break;
+      case 0: break;
+   }
+
+   /* Force "avalanching" of final 127 bits */
+   hash ^= hash << 3;
+   hash += hash >> 5;
+   hash ^= hash << 4;
+   hash += hash >> 17;
+   hash ^= hash << 25;
+   hash += hash >> 6;
+
+   return hash;
+}
+
+unsigned int stb_hash_number(unsigned int hash)
+{
+   hash ^= hash << 3;
+   hash += hash >> 5;
+   hash ^= hash << 4;
+   hash += hash >> 17;
+   hash ^= hash << 25;
+   hash += hash >> 6;
+   return hash;
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                     Perfect hashing for ints/pointers
+//
+//   This is mainly useful for making faster pointer-indexed tables
+//   that don't change frequently. E.g. for stb_ischar().
+//
+
+typedef struct
+{
+   stb_uint32  addend;
+   stb_uint    multiplicand;
+   stb_uint    b_mask;
+   stb_uint8   small_bmap[16];
+   stb_uint16  *large_bmap;
+
+   stb_uint table_mask;
+   stb_uint32 *table;
+} stb_perfect;
+
+STB_EXTERN int stb_perfect_create(stb_perfect *,unsigned int*,int n);
+STB_EXTERN void stb_perfect_destroy(stb_perfect *);
+STB_EXTERN int stb_perfect_hash(stb_perfect *, unsigned int x);
+extern int stb_perfect_hash_max_failures;
+
+#ifdef STB_DEFINE
+
+int stb_perfect_hash_max_failures;
+
+int stb_perfect_hash(stb_perfect *p, unsigned int x)
+{
+   stb_uint m = x * p->multiplicand;
+   stb_uint y = x >> 16;
+   stb_uint bv = (m >> 24) + y;
+   stb_uint av = (m + y) >> 12;
+   if (p->table == NULL) return -1;  // uninitialized table fails
+   bv &= p->b_mask;
+   av &= p->table_mask;
+   if (p->large_bmap)
+      av ^= p->large_bmap[bv];
+   else
+      av ^= p->small_bmap[bv];
+   return p->table[av] == x ? av : -1;
+}
+
+static void stb__perfect_prehash(stb_perfect *p, stb_uint x, stb_uint16 *a, stb_uint16 *b)
+{
+   stb_uint m = x * p->multiplicand;
+   stb_uint y = x >> 16;
+   stb_uint bv = (m >> 24) + y;
+   stb_uint av = (m + y) >> 12;
+   bv &= p->b_mask;
+   av &= p->table_mask;
+   *b = bv;
+   *a = av;
+}
+
+static unsigned long stb__perfect_rand(void)
+{
+   static unsigned long stb__rand;
+   stb__rand = stb__rand * 2147001325 + 715136305;
+   return 0x31415926 ^ ((stb__rand >> 16) + (stb__rand << 16));
+}
+
+typedef struct {
+   unsigned short count;
+   unsigned short b;
+   unsigned short map;
+   unsigned short *entries;
+} stb__slot;
+
+static int stb__slot_compare(const void *p, const void *q)
+{
+   stb__slot *a = (stb__slot *) p;
+   stb__slot *b = (stb__slot *) q;
+   return a->count > b->count ? -1 : a->count < b->count;  // sort large to small
+}
+
+int stb_perfect_create(stb_perfect *p, unsigned int *v, int n)
+{
+   unsigned int buffer1[64], buffer2[64], buffer3[64], buffer4[64], buffer5[32];
+   unsigned short *as = (unsigned short *) stb_temp(buffer1, sizeof(*v)*n);
+   unsigned short *bs = (unsigned short *) stb_temp(buffer2, sizeof(*v)*n);
+   unsigned short *entries = (unsigned short *) stb_temp(buffer4, sizeof(*entries) * n);
+   int size = 1 << stb_log2_ceil(n), bsize=8;
+   int failure = 0,i,j,k;
+
+   assert(n <= 32768);
+   p->large_bmap = NULL;
+
+   for(;;) {
+      stb__slot *bcount = (stb__slot *) stb_temp(buffer3, sizeof(*bcount) * bsize);
+      unsigned short *bloc = (unsigned short *) stb_temp(buffer5, sizeof(*bloc) * bsize);
+      unsigned short *e;
+      int bad=0;
+
+      p->addend = stb__perfect_rand();
+      p->multiplicand = stb__perfect_rand() | 1;
+      p->table_mask = size-1;
+      p->b_mask = bsize-1;
+      p->table = (stb_uint32 *) malloc(size * sizeof(*p->table));
+
+      for (i=0; i < bsize; ++i) {
+         bcount[i].b     = i;
+         bcount[i].count = 0;
+         bcount[i].map   = 0;
+      }
+      for (i=0; i < n; ++i) {
+         stb__perfect_prehash(p, v[i], as+i, bs+i);
+         ++bcount[bs[i]].count;
+      }
+      qsort(bcount, bsize, sizeof(*bcount), stb__slot_compare);
+      e = entries; // now setup up their entries index
+      for (i=0; i < bsize; ++i) {
+         bcount[i].entries = e;
+         e += bcount[i].count;
+         bcount[i].count = 0;
+         bloc[bcount[i].b] = i;
+      }
+      // now fill them out
+      for (i=0; i < n; ++i) {
+         int b = bs[i];
+         int w = bloc[b];
+         bcount[w].entries[bcount[w].count++] = i;
+      }
+      stb_tempfree(buffer5,bloc);
+      // verify
+      for (i=0; i < bsize; ++i)
+         for (j=0; j < bcount[i].count; ++j)
+            assert(bs[bcount[i].entries[j]] == bcount[i].b);
+      memset(p->table, 0, size*sizeof(*p->table));
+
+      // check if any b has duplicate a
+      for (i=0; i < bsize; ++i) {
+         if (bcount[i].count > 1) {
+            for (j=0; j < bcount[i].count; ++j) {
+               if (p->table[as[bcount[i].entries[j]]])
+                  bad = 1;
+               p->table[as[bcount[i].entries[j]]] = 1;
+            }
+            for (j=0; j < bcount[i].count; ++j) {
+               p->table[as[bcount[i].entries[j]]] = 0;
+            }
+            if (bad) break;
+         }
+      }
+
+      if (!bad) {
+         // go through the bs and populate the table, first fit
+         for (i=0; i < bsize; ++i) {
+            if (bcount[i].count) {
+               // go through the candidate table[b] values
+               for (j=0; j < size; ++j) {
+                  // go through the a values and see if they fit
+                  for (k=0; k < bcount[i].count; ++k) {
+                     int a = as[bcount[i].entries[k]];
+                     if (p->table[(a^j)&p->table_mask]) {
+                        break; // fails
+                     }
+                  }
+                  // if succeeded, accept
+                  if (k == bcount[i].count) {
+                     bcount[i].map = j;
+                     for (k=0; k < bcount[i].count; ++k) {
+                        int a = as[bcount[i].entries[k]];
+                        p->table[(a^j)&p->table_mask] = 1;
+                     }
+                     break;
+                  }
+               }
+               if (j == size)
+                  break; // no match for i'th entry, so break out in failure
+            }
+         }
+         if (i == bsize) {
+            // success... fill out map
+            if (bsize <= 16 && size <= 256) {
+               p->large_bmap = NULL;
+               for (i=0; i < bsize; ++i)
+                  p->small_bmap[bcount[i].b] = (stb_uint8) bcount[i].map;
+            } else {
+               p->large_bmap = (unsigned short *) malloc(sizeof(*p->large_bmap) * bsize);
+               for (i=0; i < bsize; ++i)
+                  p->large_bmap[bcount[i].b] = bcount[i].map;
+            }
+
+            // initialize table to v[0], so empty slots will fail
+            for (i=0; i < size; ++i)
+               p->table[i] = v[0];
+
+            for (i=0; i < n; ++i)
+               if (p->large_bmap)
+                  p->table[as[i] ^ p->large_bmap[bs[i]]] = v[i];
+               else
+                  p->table[as[i] ^ p->small_bmap[bs[i]]] = v[i];
+
+            // and now validate that none of them collided
+            for (i=0; i < n; ++i)
+               assert(stb_perfect_hash(p, v[i]) >= 0);
+
+            stb_tempfree(buffer3, bcount);
+            break;
+         }
+      }
+      free(p->table);
+      p->table = NULL;
+      stb_tempfree(buffer3, bcount);
+
+      ++failure;
+      if (failure >= 4 && bsize < size) bsize *= 2;
+      if (failure >= 8 && (failure & 3) == 0 && size < 4*n) {
+         size *= 2;
+         bsize *= 2;
+      }
+      if (failure == 6) {
+         // make sure the input data is unique, so we don't infinite loop
+         unsigned int *data = (unsigned int *) stb_temp(buffer3, n * sizeof(*data));
+         memcpy(data, v, sizeof(*data) * n);
+         qsort(data, n, sizeof(*data), stb_intcmp(0));
+         for (i=1; i < n; ++i) {
+            if (data[i] == data[i-1])
+               size = 0; // size is return value, so 0 it
+         }
+         stb_tempfree(buffer3, data);
+         if (!size) break;
+      }
+   }
+
+   if (failure > stb_perfect_hash_max_failures)
+      stb_perfect_hash_max_failures = failure;
+
+   stb_tempfree(buffer1, as);
+   stb_tempfree(buffer2, bs);
+   stb_tempfree(buffer4, entries);
+
+   return size;
+}
+
+void stb_perfect_destroy(stb_perfect *p)
+{
+   if (p->large_bmap) free(p->large_bmap);
+   if (p->table     ) free(p->table);
+   p->large_bmap = NULL;
+   p->table      = NULL;
+   p->b_mask     = 0;
+   p->table_mask = 0;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                     Perfect hash clients
+
+STB_EXTERN int    stb_ischar(char s, char *set);
+
+#ifdef STB_DEFINE
+
+int stb_ischar(char c, char *set)
+{
+   static unsigned char bit[8] = { 1,2,4,8,16,32,64,128 };
+   static stb_perfect p;
+   static unsigned char (*tables)[256];
+   static char ** sets = NULL;
+
+   int z = stb_perfect_hash(&p, (int) set);
+   if (z < 0) {
+      int i,k,n,j,f;
+      // special code that means free all existing data
+      if (set == NULL) {
+         stb_arr_free(sets);
+         free(tables);
+         tables = NULL;
+         stb_perfect_destroy(&p);
+         return 0;
+      }
+      stb_arr_push(sets, set);
+      stb_perfect_destroy(&p);
+      n = stb_perfect_create(&p, (unsigned int *) (char **) sets, stb_arr_len(sets));
+      assert(n != 0);
+      k = (n+7) >> 3;
+      tables = (unsigned char (*)[256]) realloc(tables, sizeof(*tables) * k);
+      memset(tables, 0, sizeof(*tables) * k);
+      for (i=0; i < stb_arr_len(sets); ++i) {
+         k = stb_perfect_hash(&p, (int) sets[i]);
+         assert(k >= 0);
+         n = k >> 3;
+         f = bit[k&7];
+         for (j=0; !j || sets[i][j]; ++j) {
+            tables[n][(unsigned char) sets[i][j]] |= f;
+         }
+      }
+      z = stb_perfect_hash(&p, (int) set);
+   }
+   return tables[z >> 3][(unsigned char) c] & bit[z & 7];
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                     Instantiated data structures
+//
+// This is an attempt to implement a templated data structure.
+//
+// Hash table: call stb_define_hash(TYPE,N,KEY,K1,K2,HASH,VALUE)
+//     TYPE     -- will define a structure type containing the hash table
+//     N        -- the name, will prefix functions named:
+//                        N create
+//                        N destroy
+//                        N get
+//                        N set, N add, N update,
+//                        N remove
+//     KEY      -- the type of the key. 'x == y' must be valid
+//       K1,K2  -- keys never used by the app, used as flags in the hashtable
+//       HASH   -- a piece of code ending with 'return' that hashes key 'k'
+//     VALUE    -- the type of the value. 'x = y' must be valid
+//
+//  Note that stb_define_hash_base can be used to define more sophisticated
+//  hash tables, e.g. those that make copies of the key or use special
+//  comparisons (e.g. strcmp).
+
+#define STB_(prefix,name)     stb__##prefix##name
+#define STB__(prefix,name)    prefix##name
+#define STB__use(x)           x
+#define STB__skip(x)
+
+#define stb_declare_hash(PREFIX,TYPE,N,KEY,VALUE) \
+   typedef struct stb__st_##TYPE TYPE;\
+   PREFIX int STB__(N, init)(TYPE *h, int count);\
+   PREFIX int STB__(N, memory_usage)(TYPE *h);\
+   PREFIX TYPE * STB__(N, create)(void);\
+   PREFIX TYPE * STB__(N, copy)(TYPE *h);\
+   PREFIX void STB__(N, destroy)(TYPE *h);\
+   PREFIX int STB__(N,get_flag)(TYPE *a, KEY k, VALUE *v);\
+   PREFIX VALUE STB__(N,get)(TYPE *a, KEY k);\
+   PREFIX int STB__(N, set)(TYPE *a, KEY k, VALUE v);\
+   PREFIX int STB__(N, add)(TYPE *a, KEY k, VALUE v);\
+   PREFIX int STB__(N, update)(TYPE*a,KEY k,VALUE v);\
+   PREFIX int STB__(N, remove)(TYPE *a, KEY k, VALUE *v);
+
+#define STB_nocopy(x)        (x)
+#define STB_nodelete(x)      0
+#define STB_nofields         
+#define STB_nonullvalue(x)
+#define STB_nullvalue(x)     x
+#define STB_safecompare(x)   x
+#define STB_nosafe(x)
+#define STB_noprefix
+
+#ifdef __GNUC__
+#define STB__nogcc(x)
+#else
+#define STB__nogcc(x)  x
+#endif
+
+#define stb_define_hash_base(PREFIX,TYPE,FIELDS,N,NC,LOAD_FACTOR,             \
+                             KEY,EMPTY,DEL,COPY,DISPOSE,SAFE,                 \
+                             VCOMPARE,CCOMPARE,HASH,                          \
+                             VALUE,HASVNULL,VNULL)                            \
+                                                                              \
+typedef struct                                                                \
+{                                                                             \
+   KEY   k;                                                                   \
+   VALUE v;                                                                   \
+} STB_(N,_hashpair);                                                          \
+                                                                              \
+STB__nogcc( typedef struct stb__st_##TYPE TYPE;  )                            \
+struct stb__st_##TYPE {                                                       \
+   FIELDS                                                                     \
+   STB_(N,_hashpair) *table;                                                  \
+   unsigned int mask;                                                         \
+   int count, limit;                                                          \
+   int deleted;                                                               \
+                                                                              \
+   int delete_threshhold;                                                     \
+   int grow_threshhold;                                                       \
+   int shrink_threshhold;                                                     \
+   unsigned char alloced, has_empty, has_del;                                 \
+   VALUE ev; VALUE dv;                                                        \
+};                                                                            \
+                                                                              \
+static unsigned int STB_(N, hash)(KEY k)                                      \
+{                                                                             \
+   HASH                                                                       \
+}                                                                             \
+                                                                              \
+PREFIX int STB__(N, init)(TYPE *h, int count)                                        \
+{                                                                             \
+   int i;                                                                     \
+   if (count < 4) count = 4;                                                  \
+   h->limit = count;                                                          \
+   h->count = 0;                                                              \
+   h->mask  = count-1;                                                        \
+   h->deleted = 0;                                                            \
+   h->grow_threshhold = (int) (count * LOAD_FACTOR);                          \
+   h->has_empty = h->has_del = 0;                                             \
+   h->alloced = 0;                                                            \
+   if (count <= 64)                                                           \
+      h->shrink_threshhold = 0;                                               \
+   else                                                                       \
+      h->shrink_threshhold = (int) (count * (LOAD_FACTOR/2.25));              \
+   h->delete_threshhold = (int) (count * (1-LOAD_FACTOR)/2);                  \
+   h->table = (STB_(N,_hashpair)*) malloc(sizeof(h->table[0]) * count);       \
+   if (h->table == NULL) return 0;                                            \
+   /* ideally this gets turned into a memset32 automatically */               \
+   for (i=0; i < count; ++i)                                                  \
+      h->table[i].k = EMPTY;                                                  \
+   return 1;                                                                  \
+}                                                                             \
+                                                                              \
+PREFIX int STB__(N, memory_usage)(TYPE *h)                                           \
+{                                                                             \
+   return sizeof(*h) + h->limit * sizeof(h->table[0]);                        \
+}                                                                             \
+                                                                              \
+PREFIX TYPE * STB__(N, create)(void)                                                 \
+{                                                                             \
+   TYPE *h = (TYPE *) malloc(sizeof(*h));                                     \
+   if (h) {                                                                   \
+      if (STB__(N, init)(h, 16))                                              \
+         h->alloced = 1;                                                      \
+      else { free(h); h=NULL; }                                               \
+   }                                                                          \
+   return h;                                                                  \
+}                                                                             \
+                                                                              \
+PREFIX void STB__(N, destroy)(TYPE *a)                                               \
+{                                                                             \
+   int i;                                                                     \
+   for (i=0; i < a->limit; ++i)                                               \
+      if (!CCOMPARE(a->table[i].k,EMPTY) && !CCOMPARE(a->table[i].k, DEL))    \
+         DISPOSE(a->table[i].k);                                              \
+   free(a->table);                                                            \
+   if (a->alloced)                                                            \
+      free(a);                                                                \
+}                                                                             \
+                                                                              \
+static void STB_(N, rehash)(TYPE *a, int count);                              \
+                                                                              \
+PREFIX int STB__(N,get_flag)(TYPE *a, KEY k, VALUE *v)                               \
+{                                                                             \
+   unsigned int h = STB_(N, hash)(k);                                         \
+   unsigned int n = h & a->mask, s;                                           \
+   if (CCOMPARE(k,EMPTY)){ if (a->has_empty) *v = a->ev; return a->has_empty;}\
+   if (CCOMPARE(k,DEL)) { if (a->has_del  ) *v = a->dv; return a->has_del;   }\
+   if (CCOMPARE(a->table[n].k,EMPTY)) return 0;                               \
+   SAFE(if (!CCOMPARE(a->table[n].k,DEL)))                                    \
+   if (VCOMPARE(a->table[n].k,k)) { *v = a->table[n].v; return 1; }            \
+   s = stb_rehash(h) | 1;                                                     \
+   for(;;) {                                                                  \
+      n = (n + s) & a->mask;                                                  \
+      if (CCOMPARE(a->table[n].k,EMPTY)) return 0;                            \
+      SAFE(if (CCOMPARE(a->table[n].k,DEL)) continue;)                        \
+      if (VCOMPARE(a->table[n].k,k))                                           \
+         { *v = a->table[n].v; return 1; }                                    \
+   }                                                                          \
+}                                                                             \
+                                                                              \
+HASVNULL(                                                                     \
+   PREFIX VALUE STB__(N,get)(TYPE *a, KEY k)                                         \
+   {                                                                          \
+      VALUE v;                                                                \
+      if (STB__(N,get_flag)(a,k,&v)) return v;                                \
+      else                           return VNULL;                            \
+   }                                                                          \
+)                                                                             \
+                                                                              \
+PREFIX int STB__(N,getkey)(TYPE *a, KEY k, KEY *kout)                                \
+{                                                                             \
+   unsigned int h = STB_(N, hash)(k);                                         \
+   unsigned int n = h & a->mask, s;                                           \
+   if (CCOMPARE(k,EMPTY)||CCOMPARE(k,DEL)) return 0;                          \
+   if (CCOMPARE(a->table[n].k,EMPTY)) return 0;                               \
+   SAFE(if (!CCOMPARE(a->table[n].k,DEL)))                                    \
+   if (VCOMPARE(a->table[n].k,k)) { *kout = a->table[n].k; return 1; }         \
+   s = stb_rehash(h) | 1;                                                     \
+   for(;;) {                                                                  \
+      n = (n + s) & a->mask;                                                  \
+      if (CCOMPARE(a->table[n].k,EMPTY)) return 0;                            \
+      SAFE(if (CCOMPARE(a->table[n].k,DEL)) continue;)                        \
+      if (VCOMPARE(a->table[n].k,k))                                          \
+         { *kout = a->table[n].k; return 1; }                                 \
+   }                                                                          \
+}                                                                             \
+                                                                              \
+static int STB_(N,addset)(TYPE *a, KEY k, VALUE v,                            \
+                             int allow_new, int allow_old, int copy)          \
+{                                                                             \
+   unsigned int h = STB_(N, hash)(k);                                         \
+   unsigned int n = h & a->mask;                                              \
+   int b = -1;                                                                \
+   if (CCOMPARE(k,EMPTY))                                                     \
+      if (a->has_empty ? allow_old : allow_new) {                             \
+          n=a->has_empty; a->ev = v; a->has_empty = 1; return !n;             \
+      } else return 0;                                                        \
+   if (CCOMPARE(k,DEL))                                                       \
+      if (a->has_del ? allow_old : allow_new) {                               \
+          n=a->has_del; a->dv = v; a->has_del = 1; return !n;                 \
+      } else return 0;                                                        \
+   if (!CCOMPARE(a->table[n].k, EMPTY)) {                                      \
+      unsigned int s;                                                         \
+      if (CCOMPARE(a->table[n].k, DEL))                                       \
+         b = n;                                                               \
+      else if (VCOMPARE(a->table[n].k,k)) {                                   \
+         if (allow_old)                                                       \
+            a->table[n].v = v;                                                \
+         return !allow_new;                                                   \
+      }                                                                       \
+      s = stb_rehash(h) | 1;                                                  \
+      for(;;) {                                                               \
+         n = (n + s) & a->mask;                                               \
+         if (CCOMPARE(a->table[n].k, EMPTY)) break;                           \
+         if (CCOMPARE(a->table[n].k, DEL)) {                                  \
+            if (b < 0) b = n;                                                 \
+         } else if (VCOMPARE(a->table[n].k,k)) {                              \
+            if (allow_old)                                                    \
+               a->table[n].v = v;                                             \
+            return !allow_new;                                                \
+         }                                                                    \
+      }                                                                       \
+   }                                                                          \
+   if (!allow_new) return 0;                                                  \
+   if (b < 0) b = n; else --a->deleted;                                       \
+   a->table[b].k = copy ? COPY(k) : k;                                        \
+   a->table[b].v = v;                                                         \
+   ++a->count;                                                                \
+   if (a->count > a->grow_threshhold)                                         \
+      STB_(N,rehash)(a, a->limit*2);                                          \
+   return 1;                                                                  \
+}                                                                             \
+                                                                              \
+PREFIX int STB__(N, set)(TYPE *a, KEY k, VALUE v){return STB_(N,addset)(a,k,v,1,1,1);}\
+PREFIX int STB__(N, add)(TYPE *a, KEY k, VALUE v){return STB_(N,addset)(a,k,v,1,0,1);}\
+PREFIX int STB__(N, update)(TYPE*a,KEY k,VALUE v){return STB_(N,addset)(a,k,v,0,1,1);}\
+                                                                              \
+PREFIX int STB__(N, remove)(TYPE *a, KEY k, VALUE *v)                                \
+{                                                                             \
+   unsigned int h = STB_(N, hash)(k);                                         \
+   unsigned int n = h & a->mask, s;                                           \
+   if (CCOMPARE(k,EMPTY)) { if (a->has_empty) { if(v)*v = a->ev; a->has_empty=0; return 1; } return 0; } \
+   if (CCOMPARE(k,DEL))   { if (a->has_del  ) { if(v)*v = a->dv; a->has_del  =0; return 1; } return 0; } \
+   if (CCOMPARE(a->table[n].k,EMPTY)) return 0;                               \
+   if (SAFE(CCOMPARE(a->table[n].k,DEL) || ) !VCOMPARE(a->table[n].k,k)) {     \
+      s = stb_rehash(h) | 1;                                                  \
+      for(;;) {                                                               \
+         n = (n + s) & a->mask;                                               \
+         if (CCOMPARE(a->table[n].k,EMPTY)) return 0;                         \
+         SAFE(if (CCOMPARE(a->table[n].k, DEL)) continue;)                    \
+         if (VCOMPARE(a->table[n].k,k)) break;                                 \
+      }                                                                       \
+   }                                                                          \
+   DISPOSE(a->table[n].k);                                                    \
+   a->table[n].k = DEL;                                                       \
+   --a->count;                                                                \
+   ++a->deleted;                                                              \
+   if (v != NULL)                                                             \
+      *v = a->table[n].v;                                                     \
+   if (a->count < a->shrink_threshhold)                                       \
+      STB_(N, rehash)(a, a->limit >> 1);                                      \
+   else if (a->deleted > a->delete_threshhold)                                \
+      STB_(N, rehash)(a, a->limit);                                           \
+   return 1;                                                                  \
+}                                                                             \
+                                                                              \
+PREFIX TYPE * STB__(NC, copy)(TYPE *a)                                        \
+{                                                                             \
+   int i;                                                                     \
+   TYPE *h = (TYPE *) malloc(sizeof(*h));                                     \
+   if (!h) return NULL;                                                       \
+   if (!STB__(N, init)(h, a->limit)) { free(h); return NULL; }                \
+   h->count = a->count;                                                       \
+   h->deleted = a->deleted;                                                   \
+   h->alloced = 1;                                                            \
+   h->ev = a->ev; h->dv = a->dv;                                              \
+   h->has_empty = a->has_empty; h->has_del = a->has_del;                      \
+   memcpy(h->table, a->table, h->limit * sizeof(h->table[0]));                \
+   for (i=0; i < a->limit; ++i)                                               \
+      if (!CCOMPARE(h->table[i].k,EMPTY) && !CCOMPARE(h->table[i].k,DEL))     \
+         h->table[i].k = COPY(h->table[i].k);                                 \
+   return h;                                                                  \
+}                                                                             \
+                                                                              \
+static void STB_(N, rehash)(TYPE *a, int count)                               \
+{                                                                             \
+   int i;                                                                     \
+   TYPE b;                                                                    \
+   STB__(N, init)(&b, count);                                                 \
+   for (i=0; i < a->limit; ++i)                                               \
+      if (!CCOMPARE(a->table[i].k,EMPTY) && !CCOMPARE(a->table[i].k,DEL))     \
+         STB_(N,addset)(&b, a->table[i].k, a->table[i].v,1,1,0);              \
+   free(a->table);                                                            \
+   a->table = b.table;                                                        \
+   a->mask = b.mask;                                                          \
+   a->count = b.count;                                                        \
+   a->limit = b.limit;                                                        \
+   a->deleted = b.deleted;                                                    \
+   a->delete_threshhold = b.delete_threshhold;                                \
+   a->grow_threshhold = b.grow_threshhold;                                    \
+   a->shrink_threshhold = b.shrink_threshhold;                                \
+}
+
+#define STB_equal(a,b)  ((a) == (b))
+
+#define stb_define_hash(TYPE,N,KEY,EMPTY,DEL,HASH,VALUE)                      \
+   stb_define_hash_base(STB_noprefix, TYPE,STB_nofields,N,NC,0.85f,              \
+              KEY,EMPTY,DEL,STB_nocopy,STB_nodelete,STB_nosafe,               \
+              STB_equal,STB_equal,HASH,                                       \
+              VALUE,STB_nonullvalue,0)
+
+#define stb_define_hash_vnull(TYPE,N,KEY,EMPTY,DEL,HASH,VALUE,VNULL)          \
+   stb_define_hash_base(STB_noprefix, TYPE,STB_nofields,N,NC,0.85f,              \
+              KEY,EMPTY,DEL,STB_nocopy,STB_nodelete,STB_nosafe,               \
+              STB_equal,STB_equal,HASH,                                       \
+              VALUE,STB_nullvalue,VNULL)
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                        stb_ptrmap
+//
+// An stb_ptrmap data structure is an O(1) hash table between pointers. One
+// application is to let you store "extra" data associated with pointers,
+// which is why it was originally called stb_extra.
+
+stb_declare_hash(STB_EXTERN, stb_ptrmap, stb_ptrmap_, void *, void *)
+stb_declare_hash(STB_EXTERN, stb_idict, stb_idict_, stb_int32, stb_int32)
+
+STB_EXTERN void        stb_ptrmap_delete(stb_ptrmap *e, void (*free_func)(void *));
+STB_EXTERN stb_ptrmap *stb_ptrmap_new(void);
+
+STB_EXTERN stb_idict * stb_idict_new_size(int size);
+STB_EXTERN void        stb_idict_remove_all(stb_idict *e);
+
+#ifdef STB_DEFINE
+
+#define STB_EMPTY ((void *) 2)
+#define STB_EDEL  ((void *) 6)
+
+stb_define_hash_base(STB_noprefix,stb_ptrmap, STB_nofields, stb_ptrmap_,stb_ptrmap_,0.85f,
+              void *,STB_EMPTY,STB_EDEL,STB_nocopy,STB_nodelete,STB_nosafe,
+              STB_equal,STB_equal,return stb_hashptr(k);,
+              void *,STB_nullvalue,NULL)
+
+stb_ptrmap *stb_ptrmap_new(void)
+{
+   return stb_ptrmap_create();
+}
+
+void stb_ptrmap_delete(stb_ptrmap *e, void (*free_func)(void *))
+{
+   int i;
+   if (free_func)
+      for (i=0; i < e->limit; ++i)
+         if (e->table[i].k != STB_EMPTY && e->table[i].k != STB_EDEL)
+            if (free_func == free)
+               free(e->table[i].v); // allow STB_MALLOC_WRAPPER to operate
+            else
+               free_func(e->table[i].v);
+   stb_ptrmap_destroy(e);
+}
+
+// extra fields needed for stua_dict
+#define STB_IEMPTY  ((int) 1)
+#define STB_IDEL    ((int) 3)
+stb_define_hash_base(STB_noprefix, stb_idict, short type; short gc; STB_nofields, stb_idict_,stb_idict_,0.85f,
+              stb_int32,STB_IEMPTY,STB_IDEL,STB_nocopy,STB_nodelete,STB_nosafe,
+              STB_equal,STB_equal,
+              return stb_rehash_improved(k);,stb_int32,STB_nonullvalue,0)
+
+stb_idict * stb_idict_new_size(int size)
+{
+   stb_idict *e = (stb_idict *) malloc(sizeof(*e));
+   if (e) {
+      if (!stb_is_pow2(size))
+         size = 1 << stb_log2_ceil(size);
+      stb_idict_init(e, size);
+      e->alloced = 1;
+   }
+   return e;
+}
+
+void stb_idict_remove_all(stb_idict *e)
+{
+   int n;
+   for (n=0; n < e->limit; ++n)
+      e->table[n].k = STB_IEMPTY;
+   e->has_empty = e->has_del = 0;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                        stb_sparse_ptr_matrix
+//
+// An stb_ptrmap data structure is an O(1) hash table storing an arbitrary
+// block of data for a given pair of pointers.
+//
+// If create=0, returns 
+
+typedef struct stb__st_stb_spmatrix stb_spmatrix;
+
+STB_EXTERN stb_spmatrix * stb_sparse_ptr_matrix_new(int val_size);
+STB_EXTERN void           stb_sparse_ptr_matrix_free(stb_spmatrix *z);
+STB_EXTERN void         * stb_sparse_ptr_matrix_get(stb_spmatrix *z, void *a, void *b, int create);
+
+#ifdef STB_DEFINE
+typedef struct
+{
+   void *a;
+   void *b;
+} stb__ptrpair;
+
+static stb__ptrpair stb__ptrpair_empty = { (void *) 1, (void *) 1 };
+static stb__ptrpair stb__ptrpair_del   = { (void *) 2, (void *) 2 };
+
+#define STB__equal_ptrpair(x,y) ((x).a == (y).a && (x).b == (y).b)
+
+stb_define_hash_base(static, stb_spmatrix, int val_size; void *arena;, stb__spmatrix_,stb__spmatrix_, 0.85,
+     stb__ptrpair, stb__ptrpair_empty, stb__ptrpair_del,
+     STB_nocopy, STB_nodelete, STB_nosafe,
+     STB__equal_ptrpair, STB__equal_ptrpair, return stb_rehash(stb_hashptr(k.a))+stb_hashptr(k.b);,
+     void *, STB_nullvalue, 0)
+
+stb_spmatrix *stb_sparse_ptr_matrix_new(int val_size)
+{
+   stb_spmatrix *m = stb__spmatrix_create();
+   if (m) m->val_size = val_size;
+   if (m) m->arena = stb_malloc_global(1);
+   return m;
+}
+
+void stb_sparse_ptr_matrix_free(stb_spmatrix *z)
+{
+   if (z->arena) stb_free(z->arena);
+   stb__spmatrix_destroy(z);
+}
+
+void *stb_sparse_ptr_matrix_get(stb_spmatrix *z, void *a, void *b, int create)
+{
+   stb__ptrpair t = { a,b };
+   void *data = stb__spmatrix_get(z, t);
+   if (!data && create) {
+      data = stb_malloc_raw(z->arena, z->val_size);
+      if (!data) return NULL;
+      memset(data, 0, z->val_size);
+      stb__spmatrix_add(z, t, data);
+   }
+   return data;
+}
+#endif
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                  SDICT: Hash Table for Strings (symbol table)
+//
+//           if "use_arena=1", then strings will be copied
+//           into blocks and never freed until the sdict is freed;
+//           otherwise they're malloc()ed and free()d on the fly. 
+//           (specify use_arena=1 if you never stb_sdict_remove)
+
+stb_declare_hash(STB_EXTERN, stb_sdict, stb_sdict_, char *, void *)
+
+STB_EXTERN stb_sdict * stb_sdict_new(int use_arena);
+STB_EXTERN stb_sdict * stb_sdict_copy(stb_sdict*); 
+STB_EXTERN void        stb_sdict_delete(stb_sdict *);
+STB_EXTERN void *      stb_sdict_change(stb_sdict *, char *str, void *p);
+STB_EXTERN int         stb_sdict_count(stb_sdict *d);
+
+#define stb_sdict_for(d,i,q,z)                                          \
+   for(i=0; i < (d)->limit ? q=(d)->table[i].k,z=(d)->table[i].v,1 : 0; ++i)    \
+      if (q==NULL||q==(void *) 1);else   // reversed makes macro friendly
+
+#ifdef STB_DEFINE
+
+#define STB_DEL ((void *) 1)
+#define STB_SDEL  ((char *) 1)
+
+#define stb_sdict__copy(x)                                       \
+   strcpy(a->arena ? stb_malloc_string(a->arena, strlen(x)+1)    \
+                   : (char *) malloc(strlen(x)+1), x)
+
+#define stb_sdict__dispose(x)  if (!a->arena) free(x)
+
+stb_define_hash_base(STB_noprefix, stb_sdict, void*arena;, stb_sdict_,stb_sdictinternal_, 0.85f,
+        char *, NULL, STB_SDEL, stb_sdict__copy, stb_sdict__dispose,
+                        STB_safecompare, !strcmp, STB_equal, return stb_hash(k);,
+        void *, STB_nullvalue, NULL)
+
+int stb_sdict_count(stb_sdict *a)
+{
+   return a->count;
+}
+
+stb_sdict * stb_sdict_new(int use_arena)
+{
+   stb_sdict *d = stb_sdict_create();
+   if (d == NULL) return NULL;
+   d->arena = use_arena ? stb_malloc_global(1) : NULL;
+   return d;
+}
+
+stb_sdict* stb_sdict_copy(stb_sdict *old)
+{
+   stb_sdict *n;
+   void *old_arena = old->arena;
+   void *new_arena = old_arena ? stb_malloc_global(1) : NULL;
+   old->arena = new_arena;
+   n = stb_sdictinternal_copy(old);
+   old->arena = old_arena;
+   if (n)
+      n->arena = new_arena;
+   else if (new_arena)
+      stb_free(new_arena);
+   return n;
+} 
+
+
+void stb_sdict_delete(stb_sdict *d)
+{
+   if (d->arena)
+      stb_free(d->arena);
+   stb_sdict_destroy(d);
+}
+
+void * stb_sdict_change(stb_sdict *d, char *str, void *p)
+{
+   void *q = stb_sdict_get(d, str);
+   stb_sdict_set(d, str, p);
+   return q;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                     Instantiated data structures
+//
+// This is an attempt to implement a templated data structure.
+// What you do is define a struct foo, and then include several
+// pointer fields to struct foo in your struct. Then you call
+// the instantiator, which creates the functions that implement
+// the data structure. This requires massive undebuggable #defines,
+// so we limit the cases where we do this.
+//
+// AA tree is an encoding of a 2-3 tree whereas RB trees encode a 2-3-4 tree;
+// much simpler code due to fewer cases.
+
+#define stb__bst_parent(x)    x
+#define stb__bst_noparent(x)
+
+#define stb_bst_fields(N)                                   \
+    *STB_(N,left), *STB_(N,right);                          \
+    unsigned char STB_(N,level)
+
+#define stb_bst_fields_parent(N)                            \
+    *STB_(N,left), *STB_(N,right),  *STB_(N,parent);        \
+    unsigned char STB_(N,level)
+
+#define STB__level(N,x)         ((x) ? (x)->STB_(N,level) : 0)
+
+#define stb_bst_base(TYPE, N, TREE, M, compare, PAR)                         \
+                                                                             \
+static int STB_(N,_compare)(TYPE *p, TYPE *q)                                \
+{                                                                            \
+   compare                                                                   \
+}                                                                            \
+                                                                             \
+static void STB_(N,setleft)(TYPE *q, TYPE *v)                                \
+{                                                                            \
+   q->STB_(N,left) = v;                                                      \
+   PAR(if (v) v->STB_(N,parent) = q;)                                        \
+}                                                                            \
+                                                                             \
+static void STB_(N,setright)(TYPE *q, TYPE *v)                               \
+{                                                                            \
+   q->STB_(N,right) = v;                                                     \
+   PAR(if (v) v->STB_(N,parent) = q;)                                        \
+}                                                                            \
+                                                                             \
+static TYPE *STB_(N,skew)(TYPE *q)                                           \
+{                                                                            \
+   if (q == NULL) return q;                                                  \
+   if (q->STB_(N,left)                                                       \
+        && q->STB_(N,left)->STB_(N,level) == q->STB_(N,level)) {             \
+      TYPE *p       = q->STB_(N,left);                                       \
+      STB_(N,setleft)(q, p->STB_(N,right));                                  \
+      STB_(N,setright)(p, q);                                                \
+      return p;                                                              \
+   }                                                                         \
+   return q;                                                                 \
+}                                                                            \
+                                                                             \
+static TYPE *STB_(N,split)(TYPE *p)                                          \
+{                                                                            \
+   TYPE *q = p->STB_(N,right);                                               \
+   if (q && q->STB_(N,right)                                                 \
+         && q->STB_(N,right)->STB_(N,level) == p->STB_(N,level)) {           \
+      STB_(N,setright)(p, q->STB_(N,left));                                  \
+      STB_(N,setleft)(q,p);                                                  \
+      ++q->STB_(N,level);                                                    \
+      return q;                                                              \
+   }                                                                         \
+   return p;                                                                 \
+}                                                                            \
+                                                                             \
+TYPE *STB__(N,insert)(TYPE *tree, TYPE *item)                                \
+{                                                                            \
+   int c;                                                                    \
+   if (tree == NULL) {                                                       \
+      item->STB_(N,left) = NULL;                                             \
+      item->STB_(N,right) = NULL;                                            \
+      item->STB_(N,level) = 1;                                               \
+      PAR(item->STB_(N,parent) = NULL;)                                      \
+      return item;                                                           \
+   }                                                                         \
+   c = STB_(N,_compare)(item,tree);                                          \
+   if (c == 0) {                                                             \
+      if (item != tree) {                                                    \
+         STB_(N,setleft)(item, tree->STB_(N,left));                          \
+         STB_(N,setright)(item, tree->STB_(N,right));                        \
+         item->STB_(N,level) = tree->STB_(N,level);                          \
+         PAR(item->STB_(N,parent) = NULL;)                                   \
+      }                                                                      \
+      return item;                                                           \
+   }                                                                         \
+   if (c < 0)                                                                \
+      STB_(N,setleft )(tree, STB__(N,insert)(tree->STB_(N,left), item));     \
+   else                                                                      \
+      STB_(N,setright)(tree, STB__(N,insert)(tree->STB_(N,right), item));    \
+   tree = STB_(N,skew)(tree);                                                \
+   tree = STB_(N,split)(tree);                                               \
+   PAR(tree->STB_(N,parent) = NULL;)                                         \
+   return tree;                                                              \
+}                                                                            \
+                                                                             \
+TYPE *STB__(N,remove)(TYPE *tree, TYPE *item)                                \
+{                                                                            \
+   static TYPE *delnode, *leaf, *restore;                                    \
+   if (tree == NULL) return NULL;                                            \
+   leaf = tree;                                                              \
+   if (STB_(N,_compare)(item, tree) < 0) {                                   \
+      STB_(N,setleft)(tree, STB__(N,remove)(tree->STB_(N,left), item));      \
+   } else {                                                                  \
+      TYPE *r;                                                               \
+      delnode = tree;                                                        \
+      r = STB__(N,remove)(tree->STB_(N,right), item);                        \
+      /* maybe move 'leaf' up to this location */                            \
+      if (restore == tree) { tree = leaf; leaf = restore = NULL;  }          \
+      STB_(N,setright)(tree,r);                                              \
+      assert(tree->STB_(N,right) != tree);                                   \
+   }                                                                         \
+   if (tree == leaf) {                                                       \
+      if (delnode == item) {                                                 \
+         tree = tree->STB_(N,right);                                         \
+         assert(leaf->STB_(N,left) == NULL);                                 \
+         /* move leaf (the right sibling) up to delnode */                   \
+         STB_(N,setleft )(leaf, item->STB_(N,left ));                        \
+         STB_(N,setright)(leaf, item->STB_(N,right));                        \
+         leaf->STB_(N,level) = item->STB_(N,level);                          \
+         if (leaf != item)                                                   \
+            restore = delnode;                                               \
+      }                                                                      \
+      delnode = NULL;                                                        \
+   } else {                                                                  \
+      if (STB__level(N,tree->STB_(N,left) ) < tree->STB_(N,level)-1 ||       \
+          STB__level(N,tree->STB_(N,right)) < tree->STB_(N,level)-1) {       \
+         --tree->STB_(N,level);                                              \
+         if (STB__level(N,tree->STB_(N,right)) > tree->STB_(N,level))        \
+            tree->STB_(N,right)->STB_(N,level) = tree->STB_(N,level);        \
+         tree = STB_(N,skew)(tree);                                          \
+         STB_(N,setright)(tree, STB_(N,skew)(tree->STB_(N,right)));          \
+         if (tree->STB_(N,right))                                            \
+            STB_(N,setright)(tree->STB_(N,right),                            \
+                  STB_(N,skew)(tree->STB_(N,right)->STB_(N,right)));         \
+         tree = STB_(N,split)(tree);                                         \
+         if (tree->STB_(N,right))                                            \
+            STB_(N,setright)(tree,  STB_(N,split)(tree->STB_(N,right)));     \
+      }                                                                      \
+   }                                                                         \
+   PAR(if (tree) tree->STB_(N,parent) = NULL;)                               \
+   return tree;                                                              \
+}                                                                            \
+                                                                             \
+TYPE *STB__(N,last)(TYPE *tree)                                              \
+{                                                                            \
+   if (tree)                                                                 \
+      while (tree->STB_(N,right)) tree = tree->STB_(N,right);                \
+   return tree;                                                              \
+}                                                                            \
+                                                                             \
+TYPE *STB__(N,first)(TYPE *tree)                                             \
+{                                                                            \
+   if (tree)                                                                 \
+      while (tree->STB_(N,left)) tree = tree->STB_(N,left);                  \
+   return tree;                                                              \
+}                                                                            \
+                                                                             \
+TYPE *STB__(N,next)(TYPE *tree, TYPE *item)                                  \
+{                                                                            \
+   TYPE *next = NULL;                                                        \
+   if (item->STB_(N,right))                                                  \
+      return STB__(N,first)(item->STB_(N,right));                            \
+   PAR(                                                                      \
+      while(item->STB_(N,parent)) {                                          \
+         TYPE *up = item->STB_(N,parent);                                    \
+         if (up->STB_(N,left) == item) return up;                            \
+         item = up;                                                          \
+      }                                                                      \
+      return NULL;                                                           \
+   )                                                                         \
+   while (tree != item) {                                                    \
+      if (STB_(N,_compare)(item, tree) < 0) {                                \
+         next = tree;                                                        \
+         tree = tree->STB_(N,left);                                          \
+      } else {                                                               \
+         tree = tree->STB_(N,right);                                         \
+      }                                                                      \
+   }                                                                         \
+   return next;                                                              \
+}                                                                            \
+                                                                             \
+TYPE *STB__(N,prev)(TYPE *tree, TYPE *item)                                  \
+{                                                                            \
+   TYPE *next = NULL;                                                        \
+   if (item->STB_(N,left))                                                   \
+      return STB__(N,last)(item->STB_(N,left));                              \
+   PAR(                                                                      \
+      while(item->STB_(N,parent)) {                                          \
+         TYPE *up = item->STB_(N,parent);                                    \
+         if (up->STB_(N,right) == item) return up;                           \
+         item = up;                                                          \
+      }                                                                      \
+      return NULL;                                                           \
+   )                                                                         \
+   while (tree != item) {                                                    \
+      if (STB_(N,_compare)(item, tree) < 0) {                                \
+         tree = tree->STB_(N,left);                                          \
+      } else {                                                               \
+         next = tree;                                                        \
+         tree = tree->STB_(N,right);                                         \
+      }                                                                      \
+   }                                                                         \
+   return next;                                                              \
+}                                                                            \
+                                                                             \
+STB__DEBUG(                                                                  \
+   void STB__(N,_validate)(TYPE *tree, int root)                             \
+   {                                                                         \
+      if (tree == NULL) return;                                              \
+      PAR(if(root) assert(tree->STB_(N,parent) == NULL);)                    \
+      assert(STB__level(N,tree->STB_(N,left) ) == tree->STB_(N,level)-1);    \
+      assert(STB__level(N,tree->STB_(N,right)) <= tree->STB_(N,level));      \
+      assert(STB__level(N,tree->STB_(N,right)) >= tree->STB_(N,level)-1);    \
+      if (tree->STB_(N,right)) {                                             \
+        assert(STB__level(N,tree->STB_(N,right)->STB_(N,right))              \
+                                               !=    tree->STB_(N,level));   \
+        PAR(assert(tree->STB_(N,right)->STB_(N,parent) == tree);)            \
+      }                                                                      \
+      PAR(if(tree->STB_(N,left)) assert(tree->STB_(N,left)->STB_(N,parent) == tree);) \
+      STB__(N,_validate)(tree->STB_(N,left) ,0);                             \
+      STB__(N,_validate)(tree->STB_(N,right),0);                             \
+   }                                                                         \
+)                                                                            \
+                                                                             \
+typedef struct                                                               \
+{                                                                            \
+   TYPE *root;                                                               \
+} TREE;                                                                      \
+                                                                             \
+void  STB__(M,Insert)(TREE *tree, TYPE *item)                                \
+{ tree->root = STB__(N,insert)(tree->root, item); }                          \
+void  STB__(M,Remove)(TREE *tree, TYPE *item)                                \
+{ tree->root = STB__(N,remove)(tree->root, item); }                          \
+TYPE *STB__(M,Next)(TREE *tree, TYPE *item)                                  \
+{ return STB__(N,next)(tree->root, item); }                                  \
+TYPE *STB__(M,Prev)(TREE *tree, TYPE *item)                                  \
+{ return STB__(N,prev)(tree->root, item); }                                  \
+TYPE *STB__(M,First)(TREE *tree) { return STB__(N,first)(tree->root); }      \
+TYPE *STB__(M,Last) (TREE *tree) { return STB__(N,last) (tree->root); }      \
+void STB__(M,Init)(TREE *tree) { tree->root = NULL; }
+
+
+#define stb_bst_find(N,tree,fcompare)                                        \
+{                                                                            \
+   int c;                                                                    \
+   while (tree != NULL) {                                                    \
+      fcompare                                                               \
+      if (c == 0) return tree;                                               \
+      if (c < 0)  tree = tree->STB_(N,left);                                 \
+      else        tree = tree->STB_(N,right);                                \
+   }                                                                         \
+   return NULL;                                                              \
+}
+
+#define stb_bst_raw(TYPE,N,TREE,M,vfield,VTYPE,compare,PAR)                  \
+   stb_bst_base(TYPE,N,TREE,M,                                               \
+         VTYPE a = p->vfield; VTYPE b = q->vfield; return (compare);, PAR )  \
+                                                                             \
+TYPE *STB__(N,find)(TYPE *tree, VTYPE a)                                     \
+   stb_bst_find(N,tree,VTYPE b = tree->vfield; c = (compare);)               \
+TYPE *STB__(M,Find)(TREE *tree, VTYPE a)                                     \
+{ return STB__(N,find)(tree->root, a); }
+
+#define stb_bst(TYPE,N,TREE,M,vfield,VTYPE,compare) \
+   stb_bst_raw(TYPE,N,TREE,M,vfield,VTYPE,compare,stb__bst_noparent)
+#define stb_bst_parent(TYPE,N,TREE,M,vfield,VTYPE,compare) \
+   stb_bst_raw(TYPE,N,TREE,M,vfield,VTYPE,compare,stb__bst_parent)
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                             Pointer Nulling
+//
+//  This lets you automatically NULL dangling pointers to "registered"
+//  objects. Note that you have to make sure you call the appropriate
+//  functions when you free or realloc blocks of memory that contain
+//  pointers or pointer targets. stb.h can automatically do this for
+//  stb_arr, or for all frees/reallocs if it's wrapping them.
+//
+
+#ifdef STB_NPTR
+
+STB_EXTERN void stb_nptr_set(void *address_of_pointer, void *value_to_write);
+STB_EXTERN void stb_nptr_didset(void *address_of_pointer);
+
+STB_EXTERN void stb_nptr_didfree(void *address_being_freed, int len);
+STB_EXTERN void stb_nptr_free(void *address_being_freed, int len);
+
+STB_EXTERN void stb_nptr_didrealloc(void *new_address, void *old_address, int len);
+STB_EXTERN void stb_nptr_recache(void); // recache all known pointers
+                                       // do this after pointer sets outside your control, slow
+
+#ifdef STB_DEFINE
+// for fast updating on free/realloc, we need to be able to find
+// all the objects (pointers and targets) within a given block;
+// this precludes hashing
+
+// we use a three-level hierarchy of memory to minimize storage:
+//   level 1: 65536 pointers to stb__memory_node (always uses 256 KB)
+//   level 2: each stb__memory_node represents a 64K block of memory
+//            with 256 stb__memory_leafs (worst case 64MB)
+//   level 3: each stb__memory_leaf represents 256 bytes of memory
+//            using a list of target locations and a list of pointers
+//            (which are hopefully fairly short normally!)
+
+// this approach won't work in 64-bit, which has a much larger address
+// space. need to redesign
+
+#define STB__NPTR_ROOT_LOG2   16
+#define STB__NPTR_ROOT_NUM    (1 << STB__NPTR_ROOT_LOG2)
+#define STB__NPTR_ROOT_SHIFT  (32 - STB__NPTR_ROOT_LOG2)
+
+#define STB__NPTR_NODE_LOG2   5
+#define STB__NPTR_NODE_NUM    (1 << STB__NPTR_NODE_LOG2)
+#define STB__NPTR_NODE_MASK   (STB__NPTR_NODE_NUM-1)
+#define STB__NPTR_NODE_SHIFT  (STB__NPTR_ROOT_SHIFT - STB__NPTR_NODE_LOG2)
+#define STB__NPTR_NODE_OFFSET(x)   (((x) >> STB__NPTR_NODE_SHIFT) & STB__NPTR_NODE_MASK)
+
+typedef struct stb__st_nptr
+{
+   void *ptr;   // address of actual pointer
+   struct stb__st_nptr *next;   // next pointer with same target
+   struct stb__st_nptr **prev;  // prev pointer with same target, address of 'next' field (or first)
+   struct stb__st_nptr *next_in_block;
+} stb__nptr;
+
+typedef struct stb__st_nptr_target
+{
+   void *ptr;   // address of target
+   stb__nptr *first; // address of first nptr pointing to this
+   struct stb__st_nptr_target *next_in_block;
+} stb__nptr_target;
+
+typedef struct
+{
+   stb__nptr *pointers;
+   stb__nptr_target *targets;
+} stb__memory_leaf;
+
+typedef struct
+{
+   stb__memory_leaf *children[STB__NPTR_NODE_NUM];
+} stb__memory_node;
+
+stb__memory_node *stb__memtab_root[STB__NPTR_ROOT_NUM];
+
+static stb__memory_leaf *stb__nptr_find_leaf(void *mem)
+{
+   stb_uint32 address = (stb_uint32) mem;
+   stb__memory_node *z = stb__memtab_root[address >> STB__NPTR_ROOT_SHIFT];
+   if (z)
+      return z->children[STB__NPTR_NODE_OFFSET(address)];
+   else
+      return NULL;      
+}
+
+static void * stb__nptr_alloc(int size)
+{
+   return stb__realloc_raw(0,size);
+}
+
+static void stb__nptr_free(void *p)
+{
+   stb__realloc_raw(p,0);
+}
+
+static stb__memory_leaf *stb__nptr_make_leaf(void *mem)
+{
+   stb_uint32 address = (stb_uint32) mem;
+   stb__memory_node *z = stb__memtab_root[address >> STB__NPTR_ROOT_SHIFT];
+   stb__memory_leaf *f;
+   if (!z) {
+      int i;
+      z = (stb__memory_node *) stb__nptr_alloc(sizeof(*stb__memtab_root[0]));
+      stb__memtab_root[address >> STB__NPTR_ROOT_SHIFT] = z;
+      for (i=0; i < 256; ++i)
+         z->children[i] = 0;
+   }
+   f = (stb__memory_leaf *) stb__nptr_alloc(sizeof(*f));
+   z->children[STB__NPTR_NODE_OFFSET(address)] = f;
+   f->pointers = NULL;
+   f->targets = NULL;
+   return f;
+}
+
+static stb__nptr_target *stb__nptr_find_target(void *target, int force)
+{
+   stb__memory_leaf *p = stb__nptr_find_leaf(target);
+   if (p) {
+      stb__nptr_target *t = p->targets;
+      while (t) {
+         if (t->ptr == target)
+            return t;
+         t = t->next_in_block;
+      }
+   }
+   if (force) {
+      stb__nptr_target *t = (stb__nptr_target*) stb__nptr_alloc(sizeof(*t));
+      if (!p) p = stb__nptr_make_leaf(target);
+      t->ptr = target;
+      t->first = NULL;
+      t->next_in_block = p->targets;
+      p->targets = t;
+      return t;
+   } else
+      return NULL;
+}
+
+static stb__nptr *stb__nptr_find_pointer(void *ptr, int force)
+{
+   stb__memory_leaf *p = stb__nptr_find_leaf(ptr);
+   if (p) {
+      stb__nptr *t = p->pointers;
+      while (t) {
+         if (t->ptr == ptr)
+            return t;
+         t = t->next_in_block;
+      }
+   }
+   if (force) {
+      stb__nptr *t = (stb__nptr *) stb__nptr_alloc(sizeof(*t));
+      if (!p) p = stb__nptr_make_leaf(ptr);
+      t->ptr = ptr;
+      t->next = NULL;
+      t->prev = NULL;
+      t->next_in_block = p->pointers;
+      p->pointers = t;
+      return t;
+   } else
+      return NULL;
+}
+
+void stb_nptr_set(void *address_of_pointer, void *value_to_write)
+{
+   if (*(void **)address_of_pointer != value_to_write) {
+      *(void **) address_of_pointer = value_to_write;
+      stb_nptr_didset(address_of_pointer);
+   }
+}
+
+void stb_nptr_didset(void *address_of_pointer)
+{
+   // first unlink from old chain
+   void *new_address;
+   stb__nptr *p = stb__nptr_find_pointer(address_of_pointer, 1); // force building if doesn't exist
+   if (p->prev) { // if p->prev is NULL, we just built it, or it was NULL
+      *(p->prev) = p->next;
+      if (p->next) p->next->prev = p->prev;
+   }
+   // now add to new chain
+   new_address = *(void **)address_of_pointer;
+   if (new_address != NULL) {
+      stb__nptr_target *t = stb__nptr_find_target(new_address, 1);
+      p->next = t->first;
+      if (p->next) p->next->prev = &p->next;
+      p->prev = &t->first;
+      t->first = p;
+   } else {
+      p->prev = NULL;
+      p->next = NULL;
+   }
+}
+
+void stb__nptr_block(void *address, int len, void (*function)(stb__memory_leaf *f, int datum, void *start, void *end), int datum)
+{
+   void *end_address = (void *) ((char *) address + len - 1);
+   stb__memory_node *n;
+   stb_uint32 start = (stb_uint32) address;
+   stb_uint32 end   = start + len - 1;
+
+   int b0 = start >> STB__NPTR_ROOT_SHIFT;
+   int b1 = end >> STB__NPTR_ROOT_SHIFT;
+   int b=b0,i,e0,e1;
+   
+   e0 = STB__NPTR_NODE_OFFSET(start);
+
+   if (datum <= 0) {
+      // first block
+      n = stb__memtab_root[b0];
+      if (n) {
+         if (b0 != b1)
+            e1 = STB__NPTR_NODE_NUM-1;
+         else
+            e1 = STB__NPTR_NODE_OFFSET(end);
+         for (i=e0; i <= e1; ++i)
+            if (n->children[i])
+               function(n->children[i], datum, address, end_address);
+      }
+      if (b1 > b0) {
+         // blocks other than the first and last block
+         for (b=b0+1; b < b1; ++b) {
+            n = stb__memtab_root[b];
+            if (n)
+               for (i=0; i <= STB__NPTR_NODE_NUM-1; ++i)
+                  if (n->children[i])
+                     function(n->children[i], datum, address, end_address);
+         }
+         // last block
+         n = stb__memtab_root[b1];
+         if (n) {
+            e1 = STB__NPTR_NODE_OFFSET(end);
+            for (i=0; i <= e1; ++i)
+               if (n->children[i])
+                  function(n->children[i], datum, address, end_address);
+         }
+      }
+   } else {
+      if (b1 > b0) {
+         // last block
+         n = stb__memtab_root[b1];
+         if (n) {
+            e1 = STB__NPTR_NODE_OFFSET(end);
+            for (i=e1; i >= 0; --i)
+               if (n->children[i])
+                  function(n->children[i], datum, address, end_address);
+         }
+         // blocks other than the first and last block
+         for (b=b1-1; b > b0; --b) {
+            n = stb__memtab_root[b];
+            if (n)
+               for (i=STB__NPTR_NODE_NUM-1; i >= 0; --i)
+                  if (n->children[i])
+                     function(n->children[i], datum, address, end_address);
+         }
+      }
+      // first block
+      n = stb__memtab_root[b0];
+      if (n) {
+         if (b0 != b1)
+            e1 = STB__NPTR_NODE_NUM-1;
+         else
+            e1 = STB__NPTR_NODE_OFFSET(end);
+         for (i=e1; i >= e0; --i)
+            if (n->children[i])
+               function(n->children[i], datum, address, end_address);
+      }
+   }
+}
+
+static void stb__nptr_delete_pointers(stb__memory_leaf *f, int offset, void *start, void *end)
+{
+   stb__nptr **p = &f->pointers;
+   while (*p) {
+      stb__nptr *n = *p;
+      if (n->ptr >= start && n->ptr <= end) {
+         // unlink
+         if (n->prev) {
+            *(n->prev) = n->next;
+            if (n->next) n->next->prev = n->prev;
+         }
+         *p = n->next_in_block;
+         stb__nptr_free(n);
+      } else
+         p = &(n->next_in_block);
+   }
+}
+
+static void stb__nptr_delete_targets(stb__memory_leaf *f, int offset, void *start, void *end)
+{
+   stb__nptr_target **p = &f->targets;
+   while (*p) {
+      stb__nptr_target *n = *p;
+      if (n->ptr >= start && n->ptr <= end) {
+         // null pointers
+         stb__nptr *z = n->first;
+         while (z) {
+            stb__nptr *y = z->next;
+            z->prev = NULL;
+            z->next = NULL;
+            *(void **) z->ptr = NULL;
+            z = y;
+         }
+         // unlink this target
+         *p = n->next_in_block;
+         stb__nptr_free(n);
+      } else
+         p = &(n->next_in_block);
+   }
+}
+
+void stb_nptr_didfree(void *address_being_freed, int len)
+{
+   // step one: delete all pointers in this block
+   stb__nptr_block(address_being_freed, len, stb__nptr_delete_pointers, 0);
+   // step two: NULL all pointers to this block; do this second to avoid NULLing deleted pointers
+   stb__nptr_block(address_being_freed, len, stb__nptr_delete_targets, 0);
+}
+
+void stb_nptr_free(void *address_being_freed, int len)
+{
+   free(address_being_freed);
+   stb_nptr_didfree(address_being_freed, len);
+}
+
+static void stb__nptr_move_targets(stb__memory_leaf *f, int offset, void *start, void *end)
+{
+   stb__nptr_target **t = &f->targets;
+   while (*t) {
+      stb__nptr_target *n = *t;
+      if (n->ptr >= start && n->ptr <= end) {
+         stb__nptr *z;
+         stb__memory_leaf *f;
+         // unlink n
+         *t = n->next_in_block;
+         // update n to new address
+         n->ptr = (void *) ((char *) n->ptr + offset);
+         f = stb__nptr_find_leaf(n->ptr);
+         if (!f) f = stb__nptr_make_leaf(n->ptr);
+         n->next_in_block = f->targets;
+         f->targets = n;
+         // now go through all pointers and make them point here
+         z = n->first;
+         while (z) {
+            *(void**) z->ptr = n->ptr;
+            z = z->next;
+         }
+      } else
+         t = &(n->next_in_block);
+   }
+}
+
+static void stb__nptr_move_pointers(stb__memory_leaf *f, int offset, void *start, void *end)
+{
+   stb__nptr **p = &f->pointers;
+   while (*p) {
+      stb__nptr *n = *p;
+      if (n->ptr >= start && n->ptr <= end) {
+         // unlink
+         *p = n->next_in_block;
+         n->ptr = (void *) ((int) n->ptr + offset);
+         // move to new block
+         f = stb__nptr_find_leaf(n->ptr);
+         if (!f) f = stb__nptr_make_leaf(n->ptr);
+         n->next_in_block = f->pointers;
+         f->pointers = n;
+      } else
+         p = &(n->next_in_block);
+   }
+}
+
+void stb_nptr_realloc(void *new_address, void *old_address, int len)
+{
+   if (new_address == old_address) return;
+
+   // have to move the pointers first, because moving the targets
+   //      requires writing to the pointers-to-the-targets, and if some of those moved too,
+   //      we need to make sure we don't write to the old memory
+
+   // step one: move all pointers within the block
+   stb__nptr_block(old_address, len, stb__nptr_move_pointers, (char *) new_address - (char *) old_address);
+   // step two: move all targets within the block
+   stb__nptr_block(old_address, len, stb__nptr_move_targets, (char *) new_address - (char *) old_address);
+}
+
+void stb_nptr_move(void *new_address, void *old_address)
+{
+   stb_nptr_realloc(new_address, old_address, 1);
+}
+
+void stb_nptr_recache(void)
+{
+   int i,j;
+   for (i=0; i < STB__NPTR_ROOT_NUM; ++i)
+      if (stb__memtab_root[i])
+         for (j=0; j < STB__NPTR_NODE_NUM; ++j)
+            if (stb__memtab_root[i]->children[j]) {
+               stb__nptr *p = stb__memtab_root[i]->children[j]->pointers;
+               while (p) {
+                  stb_nptr_didset(p->ptr);
+                  p = p->next_in_block;
+               }
+            }
+}
+
+#endif // STB_DEFINE
+#endif // STB_NPTR
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                             File Processing
+//
+
+
+#ifdef _MSC_VER
+  #define stb_rename(x,y)   _wrename(stb__from_utf8(x), stb__from_utf8_alt(y))
+  #define stb_mktemp   _mktemp
+#else
+  #define stb_mktemp   mktemp
+  #define stb_rename   rename
+#endif
+
+STB_EXTERN void     stb_fput_varlen64(FILE *f, stb_uint64 v);
+STB_EXTERN stb_uint64  stb_fget_varlen64(FILE *f);
+STB_EXTERN int      stb_size_varlen64(stb_uint64 v);
+
+
+#define stb_filec    (char *) stb_file
+#define stb_fileu    (unsigned char *) stb_file
+STB_EXTERN void *  stb_file(char *filename, size_t *length);
+STB_EXTERN void *  stb_file_max(char *filename, size_t *length);
+STB_EXTERN size_t  stb_filelen(FILE *f);
+STB_EXTERN int     stb_filewrite(char *filename, void *data, size_t length);
+STB_EXTERN int     stb_filewritestr(char *filename, char *data);
+STB_EXTERN char ** stb_stringfile(char *filename, int *len);
+STB_EXTERN char ** stb_stringfile_trimmed(char *name, int *len, char comm);
+STB_EXTERN char *  stb_fgets(char *buffer, int buflen, FILE *f);
+STB_EXTERN char *  stb_fgets_malloc(FILE *f);
+STB_EXTERN int     stb_fexists(char *filename);
+STB_EXTERN int     stb_fcmp(char *s1, char *s2);
+STB_EXTERN int     stb_feq(char *s1, char *s2);
+STB_EXTERN time_t  stb_ftimestamp(char *filename);
+
+STB_EXTERN int     stb_fullpath(char *abs, int abs_size, char *rel);
+STB_EXTERN FILE *  stb_fopen(char *filename, char *mode);
+STB_EXTERN int     stb_fclose(FILE *f, int keep);
+
+enum
+{
+   stb_keep_no = 0,
+   stb_keep_yes = 1,
+   stb_keep_if_different = 2,
+};
+
+STB_EXTERN int     stb_copyfile(char *src, char *dest);
+
+STB_EXTERN void     stb_fput_varlen64(FILE *f, stb_uint64 v);
+STB_EXTERN stb_uint64  stb_fget_varlen64(FILE *f);
+STB_EXTERN int      stb_size_varlen64(stb_uint64 v);
+
+STB_EXTERN void    stb_fwrite32(FILE *f, stb_uint32 datum);
+STB_EXTERN void    stb_fput_varlen (FILE *f, int v);
+STB_EXTERN void    stb_fput_varlenu(FILE *f, unsigned int v);
+STB_EXTERN int     stb_fget_varlen (FILE *f);
+STB_EXTERN stb_uint stb_fget_varlenu(FILE *f);
+STB_EXTERN void    stb_fput_ranged (FILE *f, int v, int b, stb_uint n);
+STB_EXTERN int     stb_fget_ranged (FILE *f, int b, stb_uint n);
+STB_EXTERN int     stb_size_varlen (int v);
+STB_EXTERN int     stb_size_varlenu(unsigned int v);
+STB_EXTERN int     stb_size_ranged (int b, stb_uint n);
+
+STB_EXTERN int     stb_fread(void *data, size_t len, size_t count, void *f);
+STB_EXTERN int     stb_fwrite(void *data, size_t len, size_t count, void *f);
+
+#if 0
+typedef struct
+{
+   FILE  *base_file;
+   char  *buffer;
+   int    buffer_size;
+   int    buffer_off;
+   int    buffer_left;
+} STBF;
+
+STB_EXTERN STBF *stb_tfopen(char *filename, char *mode);
+STB_EXTERN int stb_tfread(void *data, size_t len, size_t count, STBF *f);
+STB_EXTERN int stb_tfwrite(void *data, size_t len, size_t count, STBF *f);
+#endif
+
+#ifdef STB_DEFINE
+
+#if 0
+STBF *stb_tfopen(char *filename, char *mode)
+{
+   STBF *z;
+   FILE *f = fopen(filename, mode);
+   if (!f) return NULL;
+   z = (STBF *) malloc(sizeof(*z));
+   if (!z) { fclose(f); return NULL; }
+   z->base_file = f;
+   if (!strcmp(mode, "rb") || !strcmp(mode, "wb")) {
+      z->buffer_size = 4096;
+      z->buffer_off = z->buffer_size;
+      z->buffer_left = 0;
+      z->buffer = malloc(z->buffer_size);
+      if (!z->buffer) { free(z); fclose(f); return NULL; }
+   } else {
+      z->buffer = 0;
+      z->buffer_size = 0;
+      z->buffer_left = 0;
+   }
+   return z;
+}
+
+int stb_tfread(void *data, size_t len, size_t count, STBF *f)
+{
+   int total = len*count, done=0;
+   if (!total) return 0;
+   if (total <= z->buffer_left) {
+      memcpy(data, z->buffer + z->buffer_off, total);
+      z->buffer_off += total;
+      z->buffer_left -= total;
+      return count;
+   } else {
+      char *out = (char *) data;
+
+      // consume all buffered data
+      memcpy(data, z->buffer + z->buffer_off, z->buffer_left);
+      done = z->buffer_left;
+      out += z->buffer_left;
+      z->buffer_left=0;
+
+      if (total-done > (z->buffer_size >> 1)) {
+         done += fread(out
+      }
+   }
+}
+#endif
+
+void stb_fwrite32(FILE *f, stb_uint32 x)
+{
+   fwrite(&x, 4, 1, f);
+}
+
+#ifdef _MSC_VER
+   #define stb__stat   _stat
+#else
+   #define stb__stat   stat
+#endif
+
+int stb_fexists(char *filename)
+{
+   struct stb__stat buf;
+   return stb__windows(
+             _wstat(stb__from_utf8(filename), &buf),
+               stat(filename,&buf)
+          ) == 0;
+}
+
+time_t stb_ftimestamp(char *filename)
+{
+   struct stb__stat buf;
+   if (stb__windows(
+             _wstat(stb__from_utf8(filename), &buf),
+               stat(filename,&buf)
+          ) == 0)
+   {
+      return buf.st_mtime;
+   } else {
+      return 0;
+   }
+}
+
+size_t  stb_filelen(FILE *f)
+{
+   size_t len, pos;
+   pos = ftell(f);
+   fseek(f, 0, SEEK_END);
+   len = ftell(f);
+   fseek(f, pos, SEEK_SET);
+   return len;
+}
+
+void *stb_file(char *filename, size_t *length)
+{
+   FILE *f = stb__fopen(filename, "rb");
+   char *buffer;
+   size_t len, len2;
+   if (!f) return NULL;
+   len = stb_filelen(f);
+   buffer = (char *) malloc(len+2); // nul + extra
+   len2 = fread(buffer, 1, len, f);
+   if (len2 == len) {
+      if (length) *length = len;
+      buffer[len] = 0;
+   } else {
+      free(buffer);
+      buffer = NULL;
+   }
+   fclose(f);
+   return buffer;
+}
+
+int stb_filewrite(char *filename, void *data, size_t length)
+{
+   FILE *f = stb_fopen(filename, "wb");
+   if (f) {
+      fwrite(data, 1, length, f);
+      stb_fclose(f, stb_keep_if_different);
+   }
+   return f != NULL;
+}
+
+int stb_filewritestr(char *filename, char *data)
+{
+   return stb_filewrite(filename, data, strlen(data));
+}
+
+void *  stb_file_max(char *filename, size_t *length)
+{
+   FILE *f = stb__fopen(filename, "rb");
+   char *buffer;
+   size_t len, maxlen;
+   if (!f) return NULL;
+   maxlen = *length;
+   buffer = (char *) malloc(maxlen+1);
+   len = fread(buffer, 1, maxlen, f);
+   buffer[len] = 0;
+   fclose(f);
+   *length = len;
+   return buffer;
+}
+
+char ** stb_stringfile(char *filename, int *plen)
+{
+   FILE *f = stb__fopen(filename, "rb");
+   char *buffer, **list=NULL, *s;
+   size_t len, count, i;
+
+   if (!f) return NULL;
+   len = stb_filelen(f);
+   buffer = (char *) malloc(len+1);
+   len = fread(buffer, 1, len, f);
+   buffer[len] = 0;
+   fclose(f);
+
+   // two passes through: first time count lines, second time set them
+   for (i=0; i < 2; ++i) {
+      s = buffer;
+      if (i == 1)
+         list[0] = s;
+      count = 1;
+      while (*s) {
+         if (*s == '\n' || *s == '\r') {
+            // detect if both cr & lf are together
+            int crlf = (s[0] + s[1]) == ('\n' + '\r');
+            if (i == 1) *s = 0;
+            if (crlf) ++s;
+            if (s[1]) {  // it's not over yet
+               if (i == 1) list[count] = s+1;
+               ++count;
+            }
+         }
+         ++s;
+      }
+      if (i == 0) {
+         list = (char **) malloc(sizeof(*list) * (count+1) + len+1);
+         if (!list) return NULL;
+         list[count] = 0;
+         // recopy the file so there's just a single allocation to free
+         memcpy(&list[count+1], buffer, len+1);
+         free(buffer);
+         buffer = (char *) &list[count+1];
+         if (plen) *plen = count;
+      }
+   }
+   return list;
+}
+
+char ** stb_stringfile_trimmed(char *name, int *len, char comment)
+{
+   int i,n,o=0;
+   char **s = stb_stringfile(name, &n);
+   if (s == NULL) return NULL;
+   for (i=0; i < n; ++i) {
+      char *p = stb_skipwhite(s[i]);
+      if (*p && *p != comment)
+         s[o++] = p;
+   }
+   s[o] = NULL;
+   if (len) *len = o;
+   return s;
+}
+
+char * stb_fgets(char *buffer, int buflen, FILE *f)
+{
+   char *p;
+   buffer[0] = 0;
+   p = fgets(buffer, buflen, f);
+   if (p) {
+      int n = strlen(p)-1;
+      if (n >= 0)
+         if (p[n] == '\n')
+            p[n] = 0;
+   }
+   return p;
+}
+
+char * stb_fgets_malloc(FILE *f)
+{
+   // avoid reallocing for small strings
+   char quick_buffer[800];
+   quick_buffer[sizeof(quick_buffer)-2] = 0;
+   if (!fgets(quick_buffer, sizeof(quick_buffer), f))
+      return NULL;
+
+   if (quick_buffer[sizeof(quick_buffer)-2] == 0) {
+      int n = strlen(quick_buffer);
+      if (n > 0 && quick_buffer[n-1] == '\n')
+         quick_buffer[n-1] = 0;
+      return strdup(quick_buffer);
+   } else {
+      char *p;
+      char *a = strdup(quick_buffer);
+      int len = sizeof(quick_buffer)-1;
+
+      while (!feof(f)) {
+         if (a[len-1] == '\n') break;
+         a = (char *) realloc(a, len*2);
+         p = &a[len];
+         p[len-2] = 0;
+         if (!fgets(p, len, f))
+            break;
+         if (p[len-2] == 0) {
+            len += strlen(p);
+            break;
+         }
+         len = len + (len-1);
+      }
+      if (a[len-1] == '\n')
+         a[len-1] = 0;
+      return a;
+   }
+}
+
+int stb_fullpath(char *abs, int abs_size, char *rel)
+{
+   #ifdef _MSC_VER
+   return _fullpath(abs, rel, abs_size) != NULL;
+   #else
+   if (abs[0] == '/' || abs[0] == '~') {
+      if ((int) strlen(rel) >= abs_size)
+         return 0;
+      strcpy(abs,rel);
+      return STB_TRUE;
+   } else {
+      int n;
+      getcwd(abs, abs_size);
+      n = strlen(abs);
+      if (n+(int) strlen(rel)+2 <= abs_size) {
+         abs[n] = '/';
+         strcpy(abs+n+1, rel);
+         return STB_TRUE;
+      } else {
+         return STB_FALSE;
+      }
+   }
+   #endif
+}
+
+static int stb_fcmp_core(FILE *f, FILE *g)
+{
+   char buf1[1024],buf2[1024];
+   int n1,n2, res=0;
+
+   while (1) {
+      n1 = fread(buf1, 1, sizeof(buf1), f);
+      n2 = fread(buf2, 1, sizeof(buf2), g);
+      res = memcmp(buf1,buf2,stb_min(n1,n2));
+      if (res)
+         break;
+      if (n1 != n2) {
+         res = n1 < n2 ? -1 : 1;
+         break;
+      }
+      if (n1 == 0)
+         break;
+   }
+
+   fclose(f);
+   fclose(g);
+   return res;
+}
+
+int stb_fcmp(char *s1, char *s2)
+{
+   FILE *f = stb__fopen(s1, "rb");
+   FILE *g = stb__fopen(s2, "rb");
+
+   if (f == NULL || g == NULL) {
+      if (f) fclose(f);
+      if (g) {
+         fclose(g);
+         return STB_TRUE;
+      }
+      return f != NULL;
+   }
+
+   return stb_fcmp_core(f,g);
+}
+
+int stb_feq(char *s1, char *s2)
+{
+   FILE *f = stb__fopen(s1, "rb");
+   FILE *g = stb__fopen(s2, "rb");
+
+   if (f == NULL || g == NULL) {
+      if (f) fclose(f);
+      if (g) fclose(g);
+      return f == g;
+   }
+
+   // feq is faster because it shortcuts if they're different length
+   if (stb_filelen(f) != stb_filelen(g)) {
+      fclose(f);
+      fclose(g);
+      return 0;
+   }
+
+   return !stb_fcmp_core(f,g);
+}
+
+static stb_ptrmap *stb__files;
+
+typedef struct
+{
+   char *temp_name;
+   char *name;
+   int   errors;
+} stb__file_data;
+
+FILE *  stb_fopen(char *filename, char *mode)
+{
+   FILE *f;
+   char name_full[4096];
+   char temp_full[sizeof(name_full) + 12];
+   int j,p;
+   if (mode[0] != 'w' && !strchr(mode, '+'))
+      return stb__fopen(filename, mode);
+
+   // save away the full path to the file so if the program
+   // changes the cwd everything still works right! unix has
+   // better ways to do this, but we have to work in windows
+   if (stb_fullpath(name_full, sizeof(name_full), filename)==0)
+      return 0;
+
+   // try to generate a temporary file in the same directory
+   p = strlen(name_full)-1;
+   while (p > 0 && name_full[p] != '/' && name_full[p] != '\\'
+                && name_full[p] != ':' && name_full[p] != '~')
+      --p;
+   ++p;
+
+   memcpy(temp_full, name_full, p);
+
+   #ifdef _MSC_VER
+   // try multiple times to make a temp file... just in
+   // case some other process makes the name first
+   for (j=0; j < 32; ++j) {
+      strcpy(temp_full+p, "stmpXXXXXX");
+      if (stb_mktemp(temp_full) == NULL)
+         return 0;
+
+      f = fopen(temp_full, mode);
+      if (f != NULL)
+         break;
+   }
+   #else
+   {
+      strcpy(temp_full+p, "stmpXXXXXX");
+      int fd = mkstemp(temp_full);
+      if (fd == -1) return NULL;
+      f = fdopen(fd, mode);
+      if (f == NULL) {
+         unlink(temp_full);
+         close(fd);
+         return NULL;
+      }
+   }
+   #endif
+   if (f != NULL) {
+      stb__file_data *d = (stb__file_data *) malloc(sizeof(*d));
+      if (!d) { assert(0);  /* NOTREACHED */fclose(f); return NULL; }
+      if (stb__files == NULL) stb__files = stb_ptrmap_create();
+      d->temp_name = strdup(temp_full);
+      d->name      = strdup(name_full);
+      d->errors    = 0;
+      stb_ptrmap_add(stb__files, f, d);
+      return f;
+   }
+
+   return NULL;
+}
+
+int     stb_fclose(FILE *f, int keep)
+{
+   stb__file_data *d;
+
+   int ok = STB_FALSE;
+   if (f == NULL) return 0;
+
+   if (ferror(f))
+      keep = stb_keep_no;
+
+   fclose(f);
+
+   if (stb__files && stb_ptrmap_remove(stb__files, f, (void **) &d)) {
+      if (stb__files->count == 0) {
+         stb_ptrmap_destroy(stb__files);
+         stb__files = NULL;
+      }
+   } else
+      return STB_TRUE; // not special
+
+   if (keep == stb_keep_if_different) {
+      // check if the files are identical
+      if (stb_feq(d->name, d->temp_name)) {
+         keep = stb_keep_no;
+         ok = STB_TRUE;  // report success if no change
+      }
+   }
+
+   if (keep != stb_keep_no) {
+      if (stb_fexists(d->name) && remove(d->name)) {
+         // failed to delete old, so don't keep new
+         keep = stb_keep_no;
+      } else {
+         if (!stb_rename(d->temp_name, d->name))
+            ok = STB_TRUE;
+         else
+            keep=stb_keep_no;
+      }
+   }
+
+   if (keep == stb_keep_no)
+      remove(d->temp_name);
+
+   free(d->temp_name);
+   free(d->name);
+   free(d);
+
+   return ok;
+}
+
+int stb_copyfile(char *src, char *dest)
+{
+   char raw_buffer[1024];
+   char *buffer;
+   int buf_size = 65536;
+
+   FILE *f, *g;
+
+   // if file already exists at destination, do nothing
+   if (stb_feq(src, dest)) return STB_TRUE;
+
+   // open file
+   f = stb__fopen(src, "rb");
+   if (f == NULL) return STB_FALSE;
+
+   // open file for writing
+   g = stb__fopen(dest, "wb");
+   if (g == NULL) {
+      fclose(f);
+      return STB_FALSE;
+   }
+
+   buffer = (char *) malloc(buf_size);
+   if (buffer == NULL) {
+      buffer = raw_buffer;
+      buf_size = sizeof(raw_buffer);
+   }
+
+   while (!feof(f)) {
+      int n = fread(buffer, 1, buf_size, f);
+      if (n != 0)
+         fwrite(buffer, 1, n, g);
+   }
+
+   fclose(f);
+   if (buffer != raw_buffer)
+      free(buffer);
+
+   fclose(g);
+   return STB_TRUE;
+}
+
+// varlen:
+//    v' = (v >> 31) + (v < 0 ? ~v : v)<<1;  // small abs(v) => small v'
+// output v as big endian v'+k for v' <= k:
+//   1 byte :  v' <= 0x00000080          (  -64 <= v <   64)   7 bits
+//   2 bytes:  v' <= 0x00004000          (-8192 <= v < 8192)  14 bits
+//   3 bytes:  v' <= 0x00200000                               21 bits
+//   4 bytes:  v' <= 0x10000000                               28 bits
+// the number of most significant 1-bits in the first byte
+// equals the number of bytes after the first
+
+#define stb__varlen_xform(v)     (v<0 ? (~v << 1)+1 : (v << 1))
+
+int stb_size_varlen(int v) { return stb_size_varlenu(stb__varlen_xform(v)); }
+int stb_size_varlenu(unsigned int v)
+{
+   if (v < 0x00000080) return 1;
+   if (v < 0x00004000) return 2;
+   if (v < 0x00200000) return 3;
+   if (v < 0x10000000) return 4;
+   return 5;
+}
+
+void    stb_fput_varlen(FILE *f, int v) { stb_fput_varlenu(f, stb__varlen_xform(v)); }
+
+void    stb_fput_varlenu(FILE *f, unsigned int z)
+{
+   if (z >= 0x10000000) fputc(0xF0,f);
+   if (z >= 0x00200000) fputc((z < 0x10000000 ? 0xE0 : 0)+(z>>24),f);
+   if (z >= 0x00004000) fputc((z < 0x00200000 ? 0xC0 : 0)+(z>>16),f);
+   if (z >= 0x00000080) fputc((z < 0x00004000 ? 0x80 : 0)+(z>> 8),f);
+   fputc(z,f);
+}
+
+#define stb_fgetc(f)    ((unsigned char) fgetc(f))
+
+int     stb_fget_varlen(FILE *f)
+{
+   unsigned int z = stb_fget_varlenu(f);
+   return (z & 1) ? ~(z>>1) : (z>>1);
+}
+
+unsigned int stb_fget_varlenu(FILE *f)
+{
+   unsigned int z;
+   unsigned char d;
+   d = stb_fgetc(f);
+
+   if (d >= 0x80) {
+      if (d >= 0xc0) {
+         if (d >= 0xe0) {
+            if (d == 0xf0) z = stb_fgetc(f) << 24;
+            else           z = (d - 0xe0) << 24;
+            z += stb_fgetc(f) << 16;
+         }
+         else
+            z = (d - 0xc0) << 16;
+         z += stb_fgetc(f) << 8;
+      } else
+         z = (d - 0x80) <<  8;
+      z += stb_fgetc(f);
+   } else
+      z = d;
+   return z;
+}
+
+stb_uint64   stb_fget_varlen64(FILE *f)
+{
+   stb_uint64 z;
+   unsigned char d;
+   d = stb_fgetc(f);
+
+   if (d >= 0x80) {
+      if (d >= 0xc0) {
+         if (d >= 0xe0) {
+            if (d >= 0xf0) {
+               if (d >= 0xf8) {
+                  if (d >= 0xfc) {
+                     if (d >= 0xfe) {
+                        if (d >= 0xff)
+                           z = (stb_uint64) stb_fgetc(f) << 56;
+                        else
+                           z = (stb_uint64) (d - 0xfe) << 56;
+                        z |= (stb_uint64) stb_fgetc(f) << 48;
+                     } else z = (stb_uint64) (d - 0xfc) << 48;
+                     z |= (stb_uint64) stb_fgetc(f) << 40;
+                  } else z = (stb_uint64) (d - 0xf8) << 40;
+                  z |= (stb_uint64) stb_fgetc(f) << 32;
+               } else z = (stb_uint64) (d - 0xf0) << 32;
+               z |= (stb_uint) stb_fgetc(f) << 24;
+            } else z = (stb_uint) (d - 0xe0) << 24;
+            z |= (stb_uint) stb_fgetc(f) << 16;
+         } else z = (stb_uint) (d - 0xc0) << 16;
+         z |= (stb_uint) stb_fgetc(f) << 8;
+      } else z = (stb_uint) (d - 0x80) << 8;
+      z |= stb_fgetc(f);
+   } else
+      z = d;
+
+   return (z & 1) ? ~(z >> 1) : (z >> 1);
+}
+
+int stb_size_varlen64(stb_uint64 v)
+{
+   if (v < 0x00000080) return 1;
+   if (v < 0x00004000) return 2;
+   if (v < 0x00200000) return 3;
+   if (v < 0x10000000) return 4;
+   if (v < STB_IMM_UINT64(0x0000000800000000)) return 5;
+   if (v < STB_IMM_UINT64(0x0000040000000000)) return 6;
+   if (v < STB_IMM_UINT64(0x0002000000000000)) return 7;
+   if (v < STB_IMM_UINT64(0x0100000000000000)) return 8; 
+   return 9;
+}
+
+void    stb_fput_varlen64(FILE *f, stb_uint64 v)
+{
+   stb_uint64 z = stb__varlen_xform(v);
+   int first=1;
+   if (z >= STB_IMM_UINT64(0x100000000000000)) {
+      fputc(0xff,f);
+      first=0;
+   }
+   if (z >= STB_IMM_UINT64(0x02000000000000)) fputc((first ? 0xFE : 0)+(char)(z>>56),f), first=0;
+   if (z >= STB_IMM_UINT64(0x00040000000000)) fputc((first ? 0xFC : 0)+(char)(z>>48),f), first=0;
+   if (z >= STB_IMM_UINT64(0x00000800000000)) fputc((first ? 0xF8 : 0)+(char)(z>>40),f), first=0;
+   if (z >= STB_IMM_UINT64(0x00000010000000)) fputc((first ? 0xF0 : 0)+(char)(z>>32),f), first=0;
+   if (z >= STB_IMM_UINT64(0x00000000200000)) fputc((first ? 0xE0 : 0)+(char)(z>>24),f), first=0;
+   if (z >= STB_IMM_UINT64(0x00000000004000)) fputc((first ? 0xC0 : 0)+(char)(z>>16),f), first=0;
+   if (z >= STB_IMM_UINT64(0x00000000000080)) fputc((first ? 0x80 : 0)+(char)(z>> 8),f), first=0; 
+   fputc((char)z,f);
+}
+
+void    stb_fput_ranged(FILE *f, int v, int b, stb_uint n)
+{
+   v -= b;
+   if (n <= (1 << 31))
+      assert((stb_uint) v < n);
+   if (n > (1 << 24)) fputc(v >> 24, f);
+   if (n > (1 << 16)) fputc(v >> 16, f);
+   if (n > (1 <<  8)) fputc(v >>  8, f);
+   fputc(v,f);
+}
+
+int     stb_fget_ranged(FILE *f, int b, stb_uint n)
+{
+   unsigned int v=0;
+   if (n > (1 << 24)) v += stb_fgetc(f) << 24;
+   if (n > (1 << 16)) v += stb_fgetc(f) << 16;
+   if (n > (1 <<  8)) v += stb_fgetc(f) <<  8;
+   v += stb_fgetc(f);
+   return b+v;
+}
+
+int     stb_size_ranged(int b, stb_uint n)
+{
+   if (n > (1 << 24)) return 4;
+   if (n > (1 << 16)) return 3;
+   if (n > (1 <<  8)) return 2;
+   return 1;
+}
+
+void stb_fput_string(FILE *f, char *s)
+{
+   int len = strlen(s);
+   stb_fput_varlenu(f, len);
+   fwrite(s, 1, len, f);
+}
+
+// inverse of the above algorithm
+char *stb_fget_string(FILE *f, void *p)
+{
+   char *s;
+   int len = stb_fget_varlenu(f);
+   if (len > 4096) return NULL;
+   s = p ? stb_malloc_string(p, len+1) : (char *) malloc(len+1);
+   fread(s, 1, len, f);
+   s[len] = 0;
+   return s;
+}
+
+char *stb_strdup(char *str, void *pool)
+{
+   int len = strlen(str);
+   char *p = stb_malloc_string(pool, len+1);
+   strcpy(p, str);
+   return p;
+}
+
+// strip the trailing '/' or '\\' from a directory so we can refer to it
+// as a file for _stat()
+char *stb_strip_final_slash(char *t)
+{
+   if (t[0]) {
+      char *z = t + strlen(t) - 1;
+      // *z is the last character
+      if (*z == '\\' || *z == '/')
+         if (z != t+2 || t[1] != ':') // but don't strip it if it's e.g. "c:/"
+            *z = 0;
+      if (*z == '\\')
+         *z = '/'; // canonicalize to make sure it matches db
+   }
+   return t;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                 Options parsing
+//
+
+STB_EXTERN char **stb_getopt_param(int *argc, char **argv, char *param);
+STB_EXTERN char **stb_getopt(int *argc, char **argv);
+STB_EXTERN void   stb_getopt_free(char **opts);
+
+#ifdef STB_DEFINE
+
+void   stb_getopt_free(char **opts)
+{
+   int i;
+   char ** o2 = opts;
+   for (i=0; i < stb_arr_len(o2); ++i)
+      free(o2[i]);
+   stb_arr_free(o2);
+}
+
+char **stb_getopt(int *argc, char **argv)
+{
+   return stb_getopt_param(argc, argv, "");
+}
+
+char **stb_getopt_param(int *argc, char **argv, char *param)
+{
+   char ** opts=NULL;
+   int i,j=1;
+   for (i=1; i < *argc; ++i) {
+      if (argv[i][0] != '-') {
+         argv[j++] = argv[i];
+      } else {
+         if (argv[i][1] == 0) { // plain - == don't parse further options
+            ++i;
+            while (i < *argc)
+               argv[j++] = argv[i++];
+            break;
+         } else {
+            int k;
+            char *q = argv[i];  // traverse options list
+            for (k=1; q[k]; ++k) {
+               char *s;
+               if (strchr(param, q[k])) {  // does it take a parameter?
+                  char *t = &q[k+1], z = q[k];
+                  int len=0;
+                  if (*t == 0) {
+                     if (i == *argc-1) { // takes a parameter, but none found
+                        *argc = 0;
+                        stb_getopt_free(opts);
+                        return NULL;
+                     }
+                     t = argv[++i];
+                  } else
+                     k += strlen(t);
+                  len = strlen(t);
+                  s = (char *) malloc(len+2);
+                  if (!s) return NULL;
+                  s[0] = z;
+                  strcpy(s+1, t);
+               } else {
+                  // no parameter
+                  s = (char *) malloc(2);
+                  if (!s) return NULL;
+                  s[0] = q[k];
+                  s[1] = 0;
+               }
+               stb_arr_push(opts, s);
+            }
+         }
+      }
+   }
+   stb_arr_push(opts, NULL);
+   *argc = j;
+   return opts;
+}
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                 Portable directory reading
+//
+
+STB_EXTERN char **stb_readdir_files  (char *dir);
+STB_EXTERN char **stb_readdir_files_mask(char *dir, char *wild);
+STB_EXTERN char **stb_readdir_subdirs(char *dir);
+STB_EXTERN char **stb_readdir_subdirs_mask(char *dir, char *wild);
+STB_EXTERN void   stb_readdir_free   (char **files);
+STB_EXTERN char **stb_readdir_recursive(char *dir, char *filespec);
+STB_EXTERN void stb_delete_directory_recursive(char *dir);
+
+#ifdef STB_DEFINE
+
+#ifdef _MSC_VER
+#include <io.h>
+#else
+#include <unistd.h>
+#include <dirent.h>
+#endif
+
+void stb_readdir_free(char **files)
+{
+   char **f2 = files;
+   int i;
+   for (i=0; i < stb_arr_len(f2); ++i)
+      free(f2[i]);
+   stb_arr_free(f2);
+}
+
+STB_EXTERN int stb_wildmatchi(char *expr, char *candidate);
+static double stb_readdir_size;
+static char **readdir_raw(char *dir, int return_subdirs, char *mask)
+{
+   char **results = NULL;
+   char buffer[512], with_slash[512];
+   int n;
+
+   #ifdef _MSC_VER
+      stb__wchar *ws;
+      struct _wfinddata_t data;
+      const long none = -1;
+      long z;
+   #else
+      const DIR *none = NULL;
+      DIR *z;
+   #endif
+
+   strcpy(buffer,dir);
+   stb_fixpath(buffer);
+   n = strlen(buffer);
+
+   if (n > 0 && (buffer[n-1] != '/')) {
+      buffer[n++] = '/';
+   }
+   buffer[n] = 0;
+   strcpy(with_slash, buffer);
+
+   #ifdef _MSC_VER
+      strcpy(buffer+n, "*.*");
+      ws = stb__from_utf8(buffer);
+      z = _wfindfirst(ws, &data);
+   #else
+      z = opendir(dir);
+   #endif
+
+
+   if (z != none) {
+      int nonempty = STB_TRUE;
+      #ifndef _MSC_VER
+      struct dirent *data = readdir(z);
+      nonempty = (data != NULL);
+      #endif
+
+      if (nonempty) {
+
+         do {
+            int is_subdir;
+            #ifdef _MSC_VER
+            char *name = stb__to_utf8(data.name);
+            if (name == NULL) {
+               fprintf(stderr, "%s to convert '%S' to %s!\n", "Unable", data.name, "utf8");
+               continue;
+            }
+            is_subdir = !!(data.attrib & _A_SUBDIR);
+            #else
+            char *name = data->d_name;
+            strcpy(buffer+n,name);
+            DIR *y = opendir(buffer);
+            is_subdir = (y != NULL);
+            if (y != NULL) closedir(y);
+            #endif
+        
+            if (is_subdir == return_subdirs) {
+               if (!is_subdir || name[0] != '.') {
+                  if (!mask || stb_wildmatchi(mask, name)) {
+                     char buffer[512],*p=buffer;
+                     sprintf(buffer, "%s%s", with_slash, name);
+                     if (buffer[0] == '.' && buffer[1] == '/')
+                        p = buffer+2;
+                     stb_arr_push(results, strdup(p));
+                     #ifdef _MSC_VER
+                     if (!is_subdir)
+                        stb_readdir_size += data.size;
+                     #endif
+                  }
+               }
+            }
+         }
+         #ifdef _MSC_VER
+         while (0 == _wfindnext(z, &data));
+         #else
+         while ((data = readdir(z)) != NULL);
+         #endif
+      }
+      #ifdef _MSC_VER
+         _findclose(z);
+      #else
+         closedir(z);
+      #endif
+   }
+   return results;
+}
+
+char **stb_readdir_files  (char *dir) { return readdir_raw(dir, 0, NULL); }
+char **stb_readdir_subdirs(char *dir) { return readdir_raw(dir, 1, NULL); }
+char **stb_readdir_files_mask(char *dir, char *wild) { return readdir_raw(dir, 0, wild); }
+char **stb_readdir_subdirs_mask(char *dir, char *wild) { return readdir_raw(dir, 1, wild); }
+
+int stb__rec_max=0x7fffffff;
+static char **stb_readdir_rec(char **sofar, char *dir, char *filespec)
+{
+   int n = strcmp(dir, ".") ? strlen(dir)+1 : 0;
+   char **files;
+   char ** dirs;
+   char **p;
+
+   if (stb_arr_len(sofar) >= stb__rec_max) return sofar;
+
+   files = stb_readdir_files_mask(dir, filespec);
+   stb_arr_for(p, files) {
+      stb_arr_push(sofar, strdup(*p));
+      if (stb_arr_len(sofar) >= stb__rec_max) break;
+   }
+   stb_readdir_free(files);
+   if (stb_arr_len(sofar) >= stb__rec_max) return sofar;
+
+   dirs = stb_readdir_subdirs(dir);
+   stb_arr_for(p, dirs)
+      sofar = stb_readdir_rec(sofar, *p, filespec);
+   stb_readdir_free(dirs);
+   return sofar;
+}
+
+char **stb_readdir_recursive(char *dir, char *filespec)
+{
+   return stb_readdir_rec(NULL, dir, filespec);
+}
+
+void stb_delete_directory_recursive(char *dir)
+{
+   char **list = stb_readdir_subdirs(dir);
+   int i;
+   for (i=0; i < stb_arr_len(list); ++i)
+      stb_delete_directory_recursive(list[i]);
+   stb_arr_free(list);
+   list = stb_readdir_files(dir);
+   for (i=0; i < stb_arr_len(list); ++i)
+      if (!remove(list[i])) {
+         // on windows, try again after making it writeable; don't ALWAYS
+         // do this first since that would be slow in the normal case
+         #ifdef _MSC_VER
+         _chmod(list[i], _S_IWRITE);
+         remove(list[i]);
+         #endif
+      }
+   stb_arr_free(list);
+   stb__windows(_rmdir,rmdir)(dir);
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//   construct trees from filenames; useful for cmirror summaries
+
+typedef struct stb_dirtree2 stb_dirtree2;
+
+struct stb_dirtree2
+{
+   stb_dirtree2 **subdirs;
+
+   // make convenient for stb_summarize_tree
+   int num_subdir;
+   float weight;
+
+   // actual data
+   char *fullpath;
+   char *relpath;
+   char **files;
+};
+
+STB_EXTERN stb_dirtree2 *stb_dirtree2_from_files_relative(char *src, char **filelist, int count);
+STB_EXTERN stb_dirtree2 *stb_dirtree2_from_files(char **filelist, int count);
+STB_EXTERN int stb_dir_is_prefix(char *dir, int dirlen, char *file);
+
+#ifdef STB_DEFINE
+
+int stb_dir_is_prefix(char *dir, int dirlen, char *file)
+{
+   if (dirlen == 0) return STB_TRUE;
+   if (stb_strnicmp(dir, file, dirlen)) return STB_FALSE;
+   if (file[dirlen] == '/' || file[dirlen] == '\\') return STB_TRUE;
+   return STB_FALSE;
+}
+
+stb_dirtree2 *stb_dirtree2_from_files_relative(char *src, char **filelist, int count)
+{
+   char buffer1[1024];
+   int i;
+   int dlen = strlen(src), elen;
+   stb_dirtree2 *d;
+   char ** descendents = NULL;
+   char ** files = NULL;
+   char *s;
+   if (!count) return NULL;
+   // first find all the ones that belong here... note this is will take O(NM) with N files and M subdirs
+   for (i=0; i < count; ++i) {
+      if (stb_dir_is_prefix(src, dlen, filelist[i])) {
+         stb_arr_push(descendents, filelist[i]);
+      }
+   }
+   if (descendents == NULL)
+      return NULL;
+   elen = dlen;
+   // skip a leading slash
+   if (elen == 0 && (descendents[0][0] == '/' || descendents[0][0] == '\\'))
+      ++elen;
+   else if (elen)
+      ++elen;
+   // now extract all the ones that have their root here
+   for (i=0; i < stb_arr_len(descendents);) {
+      if (!stb_strchr2(descendents[i]+elen, '/', '\\')) {
+         stb_arr_push(files, descendents[i]);
+         descendents[i] = descendents[stb_arr_len(descendents)-1];
+         stb_arr_pop(descendents);
+      } else
+         ++i;
+   }
+   // now create a record
+   d = (stb_dirtree2 *) malloc(sizeof(*d));
+   d->files = files;
+   d->subdirs = NULL;
+   d->fullpath = strdup(src);
+   s = stb_strrchr2(d->fullpath, '/', '\\');
+   if (s)
+      ++s;
+   else
+      s = d->fullpath;
+   d->relpath = s;
+   // now create the children
+   qsort(descendents, stb_arr_len(descendents), sizeof(char *), stb_qsort_stricmp(0));
+   buffer1[0] = 0;
+   for (i=0; i < stb_arr_len(descendents); ++i) {
+      char buffer2[1024];
+      char *s = descendents[i] + elen, *t;
+      t = stb_strchr2(s, '/', '\\');
+      assert(t);
+      stb_strncpy(buffer2, descendents[i], t-descendents[i]+1);
+      if (stb_stricmp(buffer1, buffer2)) {
+         stb_dirtree2 *t = stb_dirtree2_from_files_relative(buffer2, descendents, stb_arr_len(descendents));
+         assert(t != NULL);
+         strcpy(buffer1, buffer2);
+         stb_arr_push(d->subdirs, t);
+      }
+   }
+   d->num_subdir = stb_arr_len(d->subdirs);
+   d->weight = 0;
+   return d;
+}
+
+stb_dirtree2 *stb_dirtree2_from_files(char **filelist, int count)
+{
+   return stb_dirtree2_from_files_relative("", filelist, count);
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                 Checksums: CRC-32, ADLER32, SHA-1
+//
+//    CRC-32 and ADLER32 allow streaming blocks
+//    SHA-1 requires either a complete buffer, max size 2^32 - 73
+//          or it can checksum directly from a file, max 2^61
+
+#define STB_ADLER32_SEED   1
+#define STB_CRC32_SEED     0    // note that we logical NOT this in the code
+
+STB_EXTERN stb_uint 
+  stb_adler32(stb_uint adler32, stb_uchar *buffer, stb_uint buflen);
+STB_EXTERN stb_uint 
+  stb_crc32_block(stb_uint crc32, stb_uchar *buffer, stb_uint len);
+STB_EXTERN stb_uint stb_crc32(unsigned char *buffer, stb_uint len);
+
+STB_EXTERN void stb_sha1(
+  unsigned char output[20], unsigned char *buffer, unsigned int len);
+STB_EXTERN int stb_sha1_file(unsigned char output[20], char *file);
+
+STB_EXTERN void stb_sha1_readable(char display[27], unsigned char sha[20]);
+
+#ifdef STB_DEFINE
+stb_uint stb_crc32_block(stb_uint crc, unsigned char *buffer, stb_uint len)
+{
+   static stb_uint crc_table[256];
+   stb_uint i,j,s;
+   crc = ~crc;
+
+   if (crc_table[1] == 0)
+      for(i=0; i < 256; i++) {
+         for (s=i, j=0; j < 8; ++j)
+            s = (s >> 1) ^ (s & 1 ? 0xedb88320 : 0);
+         crc_table[i] = s;
+      }
+   for (i=0; i < len; ++i)
+      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
+   return ~crc;
+}
+
+stb_uint stb_crc32(unsigned char *buffer, stb_uint len)
+{
+   return stb_crc32_block(0, buffer, len);
+}
+
+stb_uint stb_adler32(stb_uint adler32, stb_uchar *buffer, stb_uint buflen)
+{
+   const unsigned long ADLER_MOD = 65521;
+   unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
+   unsigned long blocklen, i;
+
+   blocklen = buflen % 5552;
+   while (buflen) {
+      for (i=0; i + 7 < blocklen; i += 8) {
+         s1 += buffer[0], s2 += s1;
+         s1 += buffer[1], s2 += s1;
+         s1 += buffer[2], s2 += s1;
+         s1 += buffer[3], s2 += s1;
+         s1 += buffer[4], s2 += s1;
+         s1 += buffer[5], s2 += s1;
+         s1 += buffer[6], s2 += s1;
+         s1 += buffer[7], s2 += s1;
+
+         buffer += 8;
+      }
+
+      for (; i < blocklen; ++i)
+         s1 += *buffer++, s2 += s1;
+
+      s1 %= ADLER_MOD, s2 %= ADLER_MOD;
+      buflen -= blocklen;
+      blocklen = 5552;
+   }
+   return (s2 << 16) + s1;
+}
+
+static void stb__sha1(stb_uchar *chunk, stb_uint h[5])
+{
+   int i;
+   stb_uint a,b,c,d,e;
+   stb_uint w[80];
+
+   for (i=0; i < 16; ++i)
+      w[i] = stb_big32(&chunk[i*4]);
+   for (i=16; i < 80; ++i) {
+      stb_uint t;
+      t = w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16];
+      w[i] = (t + t) | (t >> 31);
+   }
+
+   a = h[0];
+   b = h[1];
+   c = h[2];
+   d = h[3];
+   e = h[4];
+
+   #define STB__SHA1(k,f)                                            \
+   {                                                                 \
+      stb_uint temp = (a << 5) + (a >> 27) + (f) + e + (k) + w[i];  \
+      e = d;                                                       \
+      d = c;                                                     \
+      c = (b << 30) + (b >> 2);                               \
+      b = a;                                              \
+      a = temp;                                    \
+   }
+
+   i=0;
+   for (; i < 20; ++i) STB__SHA1(0x5a827999, d ^ (b & (c ^ d))       );
+   for (; i < 40; ++i) STB__SHA1(0x6ed9eba1, b ^ c ^ d               );
+   for (; i < 60; ++i) STB__SHA1(0x8f1bbcdc, (b & c) + (d & (b ^ c)) );
+   for (; i < 80; ++i) STB__SHA1(0xca62c1d6, b ^ c ^ d               );
+
+   #undef STB__SHA1
+
+   h[0] += a;
+   h[1] += b;
+   h[2] += c;
+   h[3] += d;
+   h[4] += e;
+}
+
+void stb_sha1(stb_uchar output[20], stb_uchar *buffer, stb_uint len)
+{
+   unsigned char final_block[128];
+   stb_uint end_start, final_len, j;
+   int i;
+
+   stb_uint h[5];
+
+   h[0] = 0x67452301;
+   h[1] = 0xefcdab89;
+   h[2] = 0x98badcfe;
+   h[3] = 0x10325476;
+   h[4] = 0xc3d2e1f0;
+
+   // we need to write padding to the last one or two
+   // blocks, so build those first into 'final_block'
+
+   // we have to write one special byte, plus the 8-byte length
+
+   // compute the block where the data runs out
+   end_start = len & ~63;
+
+   // compute the earliest we can encode the length
+   if (((len+9) & ~63) == end_start) {
+      // it all fits in one block, so fill a second-to-last block
+      end_start -= 64;
+   }
+
+   final_len = end_start + 128;
+
+   // now we need to copy the data in
+   assert(end_start + 128 >= len+9);
+   assert(end_start < len || len < 64-9);
+
+   j = 0;
+   if (end_start > len)
+      j = (stb_uint) - (int) end_start;
+
+   for (; end_start + j < len; ++j)
+      final_block[j] = buffer[end_start + j];
+   final_block[j++] = 0x80;
+   while (j < 128-5) // 5 byte length, so write 4 extra padding bytes
+      final_block[j++] = 0;
+   // big-endian size
+   final_block[j++] = len >> 29;
+   final_block[j++] = len >> 21;
+   final_block[j++] = len >> 13;
+   final_block[j++] = len >>  5;
+   final_block[j++] = len <<  3;
+   assert(j == 128 && end_start + j == final_len);
+
+   for (j=0; j < final_len; j += 64) { // 512-bit chunks
+      if (j+64 >= end_start+64)
+         stb__sha1(&final_block[j - end_start], h);
+      else
+         stb__sha1(&buffer[j], h);
+   }
+
+   for (i=0; i < 5; ++i) {
+      output[i*4 + 0] = h[i] >> 24;
+      output[i*4 + 1] = h[i] >> 16;
+      output[i*4 + 2] = h[i] >>  8;
+      output[i*4 + 3] = h[i] >>  0;
+   }
+}
+
+#ifdef _MSC_VER
+int stb_sha1_file(stb_uchar output[20], char *file)
+{
+   int i;
+   stb_uint64 length=0;
+   unsigned char buffer[128];
+
+   FILE *f = stb__fopen(file, "rb");
+   stb_uint h[5];
+
+   if (f == NULL) return 0; // file not found
+
+   h[0] = 0x67452301;
+   h[1] = 0xefcdab89;
+   h[2] = 0x98badcfe;
+   h[3] = 0x10325476;
+   h[4] = 0xc3d2e1f0;
+
+   for(;;) {
+      int n = fread(buffer, 1, 64, f);
+      if (n == 64) {
+         stb__sha1(buffer, h);
+         length += n;
+      } else {
+         int block = 64;
+
+         length += n;
+
+         buffer[n++] = 0x80;
+
+         // if there isn't enough room for the length, double the block
+         if (n + 8 > 64) 
+            block = 128;
+
+         // pad to end
+         memset(buffer+n, 0, block-8-n);
+
+         i = block - 8;
+         buffer[i++] = (stb_uchar) (length >> 53);
+         buffer[i++] = (stb_uchar) (length >> 45);
+         buffer[i++] = (stb_uchar) (length >> 37);
+         buffer[i++] = (stb_uchar) (length >> 29);
+         buffer[i++] = (stb_uchar) (length >> 21);
+         buffer[i++] = (stb_uchar) (length >> 13);
+         buffer[i++] = (stb_uchar) (length >>  5);
+         buffer[i++] = (stb_uchar) (length <<  3);
+         assert(i == block);
+         stb__sha1(buffer, h);
+         if (block == 128)
+            stb__sha1(buffer+64, h);
+         else
+            assert(block == 64);
+         break;
+      }
+   }
+   fclose(f);
+
+   for (i=0; i < 5; ++i) {
+      output[i*4 + 0] = h[i] >> 24;
+      output[i*4 + 1] = h[i] >> 16;
+      output[i*4 + 2] = h[i] >>  8;
+      output[i*4 + 3] = h[i] >>  0;
+   }
+
+   return 1;
+}
+#endif // _MSC_VER
+
+// client can truncate this wherever they like
+void stb_sha1_readable(char display[27], unsigned char sha[20])
+{
+   char encoding[65] = "0123456789abcdefghijklmnopqrstuv"
+                       "wxyzABCDEFGHIJKLMNOPQRSTUVWXYZ%$";
+   int num_bits = 0, acc=0;
+   int i=0,o=0;
+   while (o < 26) {
+      int v;
+      // expand the accumulator
+      if (num_bits < 6) {
+         assert(i != 20);
+         acc += sha[i++] << num_bits;
+         num_bits += 8;
+      }
+      v = acc & ((1 << 6) - 1);
+      display[o++] = encoding[v];
+      acc >>= 6;
+      num_bits -= 6;
+   }
+   assert(num_bits == 20*8 - 26*6);
+   display[o++] = encoding[acc];   
+}
+
+#endif // STB_DEFINE
+
+///////////////////////////////////////////////////////////
+//
+// simplified WINDOWS registry interface... hopefully
+// we'll never actually use this?
+
+#if defined(_WIN32)
+
+STB_EXTERN void * stb_reg_open(char *mode, char *where); // mode: "rHKLM" or "rHKCU" or "w.."
+STB_EXTERN void   stb_reg_close(void *reg);
+STB_EXTERN int    stb_reg_read(void *zreg, char *str, void *data, unsigned long len);
+STB_EXTERN int    stb_reg_read_string(void *zreg, char *str, char *data, int len);
+STB_EXTERN void   stb_reg_write(void *zreg, char *str, void *data, unsigned long len);
+STB_EXTERN void   stb_reg_write_string(void *zreg, char *str, char *data);
+
+#if defined(STB_DEFINE) && !defined(STB_NO_REGISTRY)
+
+#define STB_HAS_REGISTRY
+
+#ifndef _WINDOWS_
+
+#define HKEY void *
+
+STB_EXTERN __declspec(dllimport) long __stdcall RegCloseKey ( HKEY hKey );
+STB_EXTERN __declspec(dllimport) long __stdcall RegCreateKeyExA ( HKEY hKey, const char * lpSubKey,
+    int  Reserved, char * lpClass, int  dwOptions, 
+    int samDesired, void *lpSecurityAttributes,     HKEY * phkResult,     int * lpdwDisposition );
+STB_EXTERN __declspec(dllimport) long __stdcall RegDeleteKeyA ( HKEY hKey, const char * lpSubKey );
+STB_EXTERN __declspec(dllimport) long __stdcall RegQueryValueExA ( HKEY hKey, const char * lpValueName,
+    int * lpReserved, unsigned long * lpType, unsigned char * lpData, unsigned long * lpcbData );
+STB_EXTERN __declspec(dllimport) long __stdcall RegSetValueExA ( HKEY hKey, const char * lpValueName,
+    int  Reserved, int  dwType, const unsigned char* lpData, int  cbData );
+STB_EXTERN __declspec(dllimport) long __stdcall  RegOpenKeyExA ( HKEY hKey, const char * lpSubKey,
+    int ulOptions, int samDesired, HKEY * phkResult );
+
+#endif // _WINDOWS_
+
+#define STB__REG_OPTION_NON_VOLATILE  0
+#define STB__REG_KEY_ALL_ACCESS       0x000f003f
+#define STB__REG_KEY_READ             0x00020019
+
+void *stb_reg_open(char *mode, char *where)
+{
+   long res;
+   HKEY base;
+   HKEY zreg;
+   if (!stb_stricmp(mode+1, "cu") || !stb_stricmp(mode+1, "hkcu"))
+      base = (HKEY) 0x80000001; // HKCU
+   else if (!stb_stricmp(mode+1, "lm") || !stb_stricmp(mode+1, "hklm"))
+      base = (HKEY) 0x80000002; // HKLM
+   else
+      return NULL;
+
+   if (mode[0] == 'r')
+      res = RegOpenKeyExA(base, where, 0, STB__REG_KEY_READ, &zreg);
+   else if (mode[0] == 'w')
+      res = RegCreateKeyExA(base, where,  0, NULL, STB__REG_OPTION_NON_VOLATILE, STB__REG_KEY_ALL_ACCESS, NULL, &zreg, NULL);
+   else
+      return NULL;
+
+   return res ? NULL : zreg;
+}
+
+void stb_reg_close(void *reg)
+{
+   RegCloseKey((HKEY) reg);
+}
+
+#define STB__REG_SZ         1
+#define STB__REG_BINARY     3
+#define STB__REG_DWORD      4
+
+int stb_reg_read(void *zreg, char *str, void *data, unsigned long len)
+{
+   unsigned long type;
+   unsigned long alen = len;
+   if (0 == RegQueryValueExA((HKEY) zreg, str, 0, &type, (unsigned char *) data, &len))
+      if (type == STB__REG_BINARY || type == STB__REG_SZ || type == STB__REG_DWORD) {
+         if (len < alen)
+            *((char *) data + len) = 0;
+         return 1;
+      }
+   return 0;
+}
+
+void stb_reg_write(void *zreg, char *str, void *data, unsigned long len)
+{
+   if (zreg)
+      RegSetValueExA((HKEY) zreg, str, 0, STB__REG_BINARY, (const unsigned char *) data, len);
+}
+
+int stb_reg_read_string(void *zreg, char *str, char *data, int len)
+{
+   if (!stb_reg_read(zreg, str, data, len)) return 0;
+   data[len-1] = 0; // force a 0 at the end of the string no matter what
+   return 1;
+}
+
+void stb_reg_write_string(void *zreg, char *str, char *data)
+{
+   if (zreg)
+      RegSetValueExA((HKEY) zreg, str, 0, STB__REG_SZ, (const unsigned char *)  data, strlen(data)+1);
+}
+#endif  // STB_DEFINE
+#endif  // _WIN32
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     stb_cfg - This is like the registry, but the config info
+//               is all stored in plain old files where we can
+//               backup and restore them easily. The LOCATION of
+//               the config files is gotten from... the registry!
+
+#ifndef STB_NO_STB_STRINGS
+typedef struct stb_cfg_st stb_cfg;
+
+STB_EXTERN stb_cfg * stb_cfg_open(char *config, char *mode); // mode = "r", "w"
+STB_EXTERN void      stb_cfg_close(stb_cfg *cfg);
+STB_EXTERN int       stb_cfg_read(stb_cfg *cfg, char *key, void *value, int len);
+STB_EXTERN void      stb_cfg_write(stb_cfg *cfg, char *key, void *value, int len);
+STB_EXTERN int       stb_cfg_read_string(stb_cfg *cfg, char *key, char *value, int len);
+STB_EXTERN void      stb_cfg_write_string(stb_cfg *cfg, char *key, char *value);
+STB_EXTERN int       stb_cfg_delete(stb_cfg *cfg, char *key);
+STB_EXTERN void      stb_cfg_set_directory(char *dir);
+
+#ifdef STB_DEFINE
+
+typedef struct
+{
+   char *key;
+   void *value;
+   int value_len;
+} stb__cfg_item;
+
+struct stb_cfg_st
+{
+   stb__cfg_item *data;
+   char *loaded_file;   // this needs to be freed
+   FILE *f; // write the data to this file on close
+};
+
+static char *stb__cfg_sig = "sTbCoNfIg!\0\0";
+static char stb__cfg_dir[512];
+STB_EXTERN void stb_cfg_set_directory(char *dir)
+{
+   strcpy(stb__cfg_dir, dir);
+}
+
+STB_EXTERN stb_cfg * stb_cfg_open(char *config, char *mode)
+{
+   unsigned int len;
+   stb_cfg *z;
+   char file[512];
+   if (mode[0] != 'r' && mode[0] != 'w') return NULL;
+
+   if (!stb__cfg_dir[0]) {
+      #ifdef _WIN32
+      strcpy(stb__cfg_dir, "c:/stb");
+      #else
+      strcpy(stb__cfg_dir, "~/.stbconfig");
+      #endif
+
+      #ifdef STB_HAS_REGISTRY
+      {
+         void *reg = stb_reg_open("rHKLM", "Software\\SilverSpaceship\\stb");
+         if (reg) {
+            stb_reg_read_string(reg, "config_dir", stb__cfg_dir, sizeof(stb__cfg_dir));
+            stb_reg_close(reg);
+         }
+      }
+      #endif
+   }
+
+   sprintf(file, "%s/%s.cfg", stb__cfg_dir, config);
+
+   z = (stb_cfg *) stb_malloc(0, sizeof(*z));
+   z->data = NULL;
+
+   z->loaded_file = stb_filec(file, &len);
+   if (z->loaded_file) {
+      char *s = z->loaded_file;
+      if (!memcmp(s, stb__cfg_sig, 12)) {
+         char *s = z->loaded_file + 12;
+         while (s < z->loaded_file + len) {
+            stb__cfg_item a;
+            int n = *(stb_int16 *) s;
+            a.key = s+2;
+            s = s+2 + n;
+            a.value_len = *(int *) s;
+            s += 4;
+            a.value = s;
+            s += a.value_len;
+            stb_arr_push(z->data, a);
+         }
+         assert(s == z->loaded_file + len);
+      }
+   }
+
+   if (mode[0] == 'w')
+      z->f = fopen(file, "wb");
+   else
+      z->f = NULL;
+
+   return z;
+}
+
+void stb_cfg_close(stb_cfg *z)
+{
+   if (z->f) {
+      int i;
+      // write the file out
+      fwrite(stb__cfg_sig, 12, 1, z->f);
+      for (i=0; i < stb_arr_len(z->data); ++i) {
+         stb_int16 n = strlen(z->data[i].key)+1;
+         fwrite(&n, 2, 1, z->f);
+         fwrite(z->data[i].key, n, 1, z->f);
+         fwrite(&z->data[i].value_len, 4, 1, z->f);
+         fwrite(z->data[i].value, z->data[i].value_len, 1, z->f);
+      }
+      fclose(z->f);
+   }
+   stb_arr_free(z->data);
+   stb_free(z);
+}
+
+int stb_cfg_read(stb_cfg *z, char *key, void *value, int len)
+{
+   int i;
+   for (i=0; i < stb_arr_len(z->data); ++i) {
+      if (!stb_stricmp(z->data[i].key, key)) {
+         int n = stb_min(len, z->data[i].value_len);
+         memcpy(value, z->data[i].value, n);
+         if (n < len)
+            *((char *) value + n) = 0;
+         return 1;
+      }
+   }
+   return 0;
+}
+
+void stb_cfg_write(stb_cfg *z, char *key, void *value, int len)
+{
+   int i;
+   for (i=0; i < stb_arr_len(z->data); ++i)
+      if (!stb_stricmp(z->data[i].key, key))
+         break;
+   if (i == stb_arr_len(z->data)) {
+      stb__cfg_item p;
+      p.key = stb_strdup(key, z);
+      p.value = NULL;
+      p.value_len = 0;
+      stb_arr_push(z->data, p);
+   }
+   z->data[i].value = stb_malloc(z, len);
+   z->data[i].value_len = len;
+   memcpy(z->data[i].value, value, len);
+}
+
+int stb_cfg_delete(stb_cfg *z, char *key)
+{
+   int i;
+   for (i=0; i < stb_arr_len(z->data); ++i)
+      if (!stb_stricmp(z->data[i].key, key)) {   
+         stb_arr_fastdelete(z->data, i);
+         return 1;
+      }
+   return 0;
+}
+
+int stb_cfg_read_string(stb_cfg *z, char *key, char *value, int len)
+{
+   if (!stb_cfg_read(z, key, value, len)) return 0;
+   value[len-1] = 0;
+   return 1;
+}
+
+void stb_cfg_write_string(stb_cfg *z, char *key, char *value)
+{
+   stb_cfg_write(z, key, value, strlen(value)+1);
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     stb_dirtree  - load a description of a directory tree
+//                      uses a cache and stat()s the directories for changes
+//                      MUCH faster on NTFS, _wrong_ on FAT32, so should
+//                      ignore the db on FAT32
+
+#ifdef _WIN32
+
+typedef struct
+{
+   char   * path;           // full path from passed-in root
+   time_t   last_modified;
+   int      num_files;
+} stb_dirtree_dir;
+
+typedef struct
+{
+   char *name;              // name relative to path
+   int   dir;               // index into dirs[] array
+   unsigned long size;      // size, max 4GB
+   time_t   last_modified;
+} stb_dirtree_file;
+
+typedef struct
+{
+   stb_dirtree_dir  *dirs;
+   stb_dirtree_file *files;
+
+   // internal use
+   void             * string_pool;   // used to free data en masse
+} stb_dirtree;
+
+extern void         stb_dirtree_free          ( stb_dirtree *d );
+extern stb_dirtree *stb_dirtree_get           ( char *dir);
+extern stb_dirtree *stb_dirtree_get_dir       ( char *dir, char *cache_dir);
+extern stb_dirtree *stb_dirtree_get_with_file ( char *dir, char *cache_file);
+
+// get a list of all the files recursively underneath 'dir'
+//
+// cache_file is used to store a copy of the directory tree to speed up
+// later calls. It must be unique to 'dir' and the current working
+// directory! Otherwise who knows what will happen (a good solution
+// is to put it _in_ dir, but this API doesn't force that).
+//
+// Also, it might be possible to break this if you have two different processes
+// do a call to stb_dirtree_get() with the same cache file at about the same
+// time, but I _think_ it might just work.
+
+
+#ifdef STB_DEFINE
+static void stb__dirtree_add_dir(char *path, time_t last, stb_dirtree *active)
+{
+   stb_dirtree_dir d;
+   d.last_modified = last;
+   d.num_files = 0;
+   d.path = stb_strdup(path, active->string_pool);
+   stb_arr_push(active->dirs, d);
+}
+
+static void stb__dirtree_add_file(char *name, int dir, unsigned long size, time_t last, stb_dirtree *active)
+{
+   stb_dirtree_file f;
+   f.dir = dir;
+   f.size = size;
+   f.last_modified = last;
+   f.name = stb_strdup(name, active->string_pool);
+   ++active->dirs[dir].num_files;
+   stb_arr_push(active->files, f);
+}
+
+static char stb__signature[12] = { 's', 'T', 'b', 'D', 'i', 'R', 't', 'R', 'e', 'E', '0', '1' };
+
+static void stb__dirtree_save_db(char *filename, stb_dirtree *data, char *root)
+{
+   int i, num_dirs_final=0, num_files_final;
+   int *remap;
+   FILE *f = fopen(filename, "wb");
+   if (!f) return;
+
+   fwrite(stb__signature, sizeof(stb__signature), 1, f);
+   fwrite(root, strlen(root)+1, 1, f);
+   // need to be slightly tricky and not write out NULLed directories, nor the root
+
+   // build remapping table of all dirs we'll be writing out
+   remap = (int *) malloc(sizeof(remap[0]) * stb_arr_len(data->dirs));
+   for (i=0; i < stb_arr_len(data->dirs); ++i) {
+      if (data->dirs[i].path == NULL || 0==stb_stricmp(data->dirs[i].path, root)) {
+         remap[i] = -1;
+      } else {
+         remap[i] = num_dirs_final++;
+      }
+   }
+
+   fwrite(&num_dirs_final, 4, 1, f);
+   for (i=0; i < stb_arr_len(data->dirs); ++i) {
+      if (remap[i] >= 0) {
+         fwrite(&data->dirs[i].last_modified, 4, 1, f);
+         stb_fput_string(f, data->dirs[i].path);
+      }
+   }
+
+   num_files_final = 0;
+   for (i=0; i < stb_arr_len(data->files); ++i)
+      if (remap[data->files[i].dir] >= 0)
+         ++num_files_final;
+
+   fwrite(&num_files_final, 4, 1, f);
+   for (i=0; i < stb_arr_len(data->files); ++i) {
+      if (remap[data->files[i].dir] >= 0) {
+         stb_fput_ranged(f, remap[data->files[i].dir], 0, num_dirs_final);
+         stb_fput_varlenu(f, data->files[i].size);
+         fwrite(&data->files[i].last_modified, 4, 1, f);
+         stb_fput_string(f, data->files[i].name);
+      }
+   }
+
+   fclose(f);
+}
+
+// note: stomps any existing data, rather than appending
+static void stb__dirtree_load_db(char *filename, stb_dirtree *data, char *dir)
+{
+   char sig[2048];
+   int i,n;
+   FILE *f = fopen(filename, "rb");
+
+   if (!f) return;
+
+   data->string_pool = stb_malloc(0,1);
+
+   fread(sig, sizeof(stb__signature), 1, f);
+   if (memcmp(stb__signature, sig, sizeof(stb__signature))) { fclose(f); return; }
+   if (!fread(sig, strlen(dir)+1, 1, f))                    { fclose(f); return; }
+   if (stb_stricmp(sig,dir))                                { fclose(f); return; }
+
+   // we can just read them straight in, because they're guaranteed to be valid
+   fread(&n, 4, 1, f);
+   stb_arr_setlen(data->dirs, n);
+   for(i=0; i < stb_arr_len(data->dirs); ++i) {
+      fread(&data->dirs[i].last_modified, 4, 1, f);
+      data->dirs[i].path = stb_fget_string(f, data->string_pool);
+      if (data->dirs[i].path == NULL) goto bail;
+   }
+   fread(&n, 4, 1, f);
+   stb_arr_setlen(data->files, n);
+   for (i=0; i < stb_arr_len(data->files); ++i) {
+      data->files[i].dir  = stb_fget_ranged(f, 0, stb_arr_len(data->dirs));
+      data->files[i].size = stb_fget_varlenu(f);
+      fread(&data->files[i].last_modified, 4, 1, f);
+      data->files[i].name = stb_fget_string(f, data->string_pool);
+      if (data->files[i].name == NULL) goto bail;
+   }
+
+   if (0) {
+      bail:
+         stb_arr_free(data->dirs);
+         stb_arr_free(data->files);
+   }
+   fclose(f);
+}
+
+static void stb__dirtree_scandir(char *path, time_t last_time, stb_dirtree *active)
+{
+   // this is dumb depth first; theoretically it might be faster
+   // to fully traverse each directory before visiting its children,
+   // but it's complicated and didn't seem like a gain in the test app
+
+   int n;
+
+   struct _wfinddata_t c_file;
+   long hFile;
+   stb__wchar full_path[1024];
+   int has_slash;
+
+   has_slash = (path[0] && path[strlen(path)-1] == '/'); 
+   if (has_slash)
+      swprintf(full_path, L"%s*", stb__from_utf8(path));
+   else
+      swprintf(full_path, L"%s/*", stb__from_utf8(path));
+
+   // it's possible this directory is already present: that means it was in the
+   // cache, but its parent wasn't... in that case, we're done with it
+   for (n=0; n < stb_arr_len(active->dirs); ++n)
+      if (0 == stb_stricmp(active->dirs[n].path, path))
+         return;
+
+   // otherwise, we need to add it
+   stb__dirtree_add_dir(path, last_time, active);
+   n = stb_arr_lastn(active->dirs);
+
+   if( (hFile = _wfindfirst( full_path, &c_file )) != -1L ) {
+      do {
+         if (c_file.attrib & _A_SUBDIR) {
+            // ignore subdirectories starting with '.', e.g. "." and ".."
+            if (c_file.name[0] != '.') {
+               char *new_path = (char *) full_path;
+               char *temp = stb__to_utf8(c_file.name);
+               if (has_slash)
+                  sprintf(new_path, "%s%s", path, temp);
+               else
+                  sprintf(new_path, "%s/%s", path, temp);
+               stb__dirtree_scandir(new_path, c_file.time_write, active);
+            }
+         } else {
+            char *temp = stb__to_utf8(c_file.name);
+            stb__dirtree_add_file(temp, n, c_file.size, c_file.time_write, active);
+         }
+      } while( _wfindnext( hFile, &c_file ) == 0 );
+
+      _findclose( hFile );
+   }
+}
+
+// scan the database and see if it's all valid
+static int stb__dirtree_update_db(stb_dirtree *db, stb_dirtree *active)
+{
+   int changes_detected = STB_FALSE;
+   int i;
+   int *remap;
+   int *rescan=NULL;
+   remap = (int *) malloc(sizeof(remap[0]) * stb_arr_len(db->dirs));
+   memset(remap, 0, sizeof(remap[0]) * stb_arr_len(db->dirs));
+   rescan = NULL;
+
+   for (i=0; i < stb_arr_len(db->dirs); ++i) {
+      struct _stat info;
+      if (0 == _stat(db->dirs[i].path, &info)) {
+         if (info.st_mode & _S_IFDIR) {
+            // it's still a directory, as expected
+            if (info.st_mtime > db->dirs[i].last_modified) {
+               // it's changed! force a rescan
+               // we don't want to scan it until we've stat()d its
+               // subdirs, though, so we queue it
+               stb_arr_push(rescan, i);
+               // update the last_mod time
+               db->dirs[i].last_modified = info.st_mtime;
+               // ignore existing files in this dir
+               remap[i] = -1;
+               changes_detected = STB_TRUE;
+            } else {
+               // it hasn't changed, just copy it through unchanged
+               stb__dirtree_add_dir(db->dirs[i].path, db->dirs[i].last_modified, active);
+               remap[i] = stb_arr_lastn(active->dirs);
+            }
+         } else {
+            // this path used to refer to a directory, but now it's a file!
+            // assume that the parent directory is going to be forced to rescan anyway
+            goto delete_entry;
+         }
+      } else {
+        delete_entry:
+         // directory no longer exists, so don't copy it
+         // we don't free it because it's in the string pool now
+         db->dirs[i].path = NULL;
+         remap[i] = -1;
+         changes_detected = STB_TRUE;
+      }
+   }
+
+   // at this point, we have:
+   //
+   //   <rescan> holds a list of directory indices that need to be scanned due to being out of date
+   //   <remap> holds the directory index in <active> for each dir in <db>, if it exists; -1 if not
+   //           directories in <rescan> are not in <active> yet
+
+   // so we can go ahead and remap all the known files right now
+   for (i=0; i < stb_arr_len(db->files); ++i) {
+      int dir = db->files[i].dir;
+      if (remap[dir] >= 0) {
+         stb__dirtree_add_file(db->files[i].name, remap[dir], db->files[i].size, db->files[i].last_modified, active);
+      }
+   }
+
+   // at this point we're done with db->files, and done with remap
+   free(remap);
+
+   // now scan those directories using the standard scan
+   for (i=0; i < stb_arr_len(rescan); ++i) {
+      int z = rescan[i];
+      stb__dirtree_scandir(db->dirs[z].path, db->dirs[z].last_modified, active);
+   }
+   stb_arr_free(rescan);
+
+   return changes_detected;
+}
+
+static void stb__dirtree_free_raw(stb_dirtree *d)
+{
+   stb_free(d->string_pool);
+   stb_arr_free(d->dirs);
+   stb_arr_free(d->files);
+}
+
+stb_dirtree *stb_dirtree_get_with_file(char *dir, char *cache_file)
+{
+   stb_dirtree *output = (stb_dirtree *) malloc(sizeof(*output));
+   stb_dirtree db,active;
+   int prev_dir_count, cache_mismatch;
+
+   char *stripped_dir; // store the directory name without a trailing '/' or '\\'
+
+   // load the database of last-known state on disk
+   db.string_pool = NULL;
+   db.files = NULL;
+   db.dirs = NULL;
+
+   stripped_dir = stb_strip_final_slash(strdup(dir));
+
+   if (cache_file != NULL)
+      stb__dirtree_load_db(cache_file, &db, stripped_dir);
+
+   active.files = NULL;
+   active.dirs = NULL;
+   active.string_pool = stb_malloc(0,1); // @TODO: share string pools between both?
+
+   // check all the directories in the database; make note if
+   // anything we scanned had changed, and rescan those things
+   cache_mismatch = stb__dirtree_update_db(&db, &active);
+
+   // check the root tree
+   prev_dir_count = stb_arr_len(active.dirs);  // record how many directories we've seen
+
+   stb__dirtree_scandir(stripped_dir, 0, &active);  // no last_modified time available for root
+
+   // done with the DB; write it back out if any changes, i.e. either
+   //      1. any inconsistency found between cached information and actual disk
+   //   or 2. if scanning the root found any new directories--which we detect because
+   //         more than one directory got added to the active db during that scan
+   if (cache_mismatch || stb_arr_len(active.dirs) > prev_dir_count+1)
+      stb__dirtree_save_db(cache_file, &active, stripped_dir);
+
+   free(stripped_dir);
+
+   stb__dirtree_free_raw(&db);
+
+   *output = active;
+   return output;
+}
+
+stb_dirtree *stb_dirtree_get_dir(char *dir, char *cache_dir)
+{
+   int i;
+   stb_uint8 sha[20];
+   char dir_lower[1024];
+   char cache_file[1024],*s;
+   if (cache_dir == NULL)
+      return stb_dirtree_get_with_file(dir, NULL);
+   strcpy(dir_lower, dir);
+   stb_tolower(dir_lower);
+   stb_sha1(sha, (unsigned char *) dir_lower, strlen(dir_lower));
+   strcpy(cache_file, cache_dir);
+   s = cache_file + strlen(cache_file);
+   if (s[-1] != '//' && s[-1] != '\\') *s++ = '/';
+   strcpy(s, "dirtree_");
+   s += strlen(s);
+   for (i=0; i < 8; ++i) {
+      char *hex = "0123456789abcdef";
+      stb_uint z = sha[i];
+      *s++ = hex[z >> 4];
+      *s++ = hex[z & 15];
+   }
+   strcpy(s, ".bin");
+   return stb_dirtree_get_with_file(dir, cache_file);
+}
+
+stb_dirtree *stb_dirtree_get(char *dir)
+{
+   char cache_dir[256];
+   strcpy(cache_dir, "c:/stb");
+   #ifdef STB_HAS_REGISTRY
+   {
+      void *reg = stb_reg_open("rHKLM", "Software\\SilverSpaceship\\stb");
+      if (reg) {
+         stb_reg_read(reg, "dirtree", cache_dir, sizeof(cache_dir));
+         stb_reg_close(reg);
+      }
+   }
+   #endif
+   return stb_dirtree_get_dir(dir, cache_dir);
+}
+
+void stb_dirtree_free(stb_dirtree *d)
+{
+   stb__dirtree_free_raw(d);
+   free(d);
+}
+#endif // STB_DEFINE
+
+#endif // _WIN32
+#endif // STB_NO_STB_STRINGS
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  STB_MALLOC_WRAPPER
+//
+//    you can use the wrapper functions with your own malloc wrapper,
+//    or define STB_MALLOC_WRAPPER project-wide to have
+//    malloc/free/realloc/strdup all get vectored to it
+
+// this has too many very specific error messages you could google for and find in stb.h,
+// so don't use it if they don't want any stb.h-identifiable strings
+#if defined(STB_DEFINE) && !defined(STB_NO_STB_STRINGS)
+
+typedef struct
+{
+   void *p;
+   char *file;
+   int  line;
+   int  size;
+} stb_malloc_record;
+
+#ifndef STB_MALLOC_HISTORY_COUNT
+#define STB_MALLOC_HISTORY_COUNT 50 // 800 bytes
+#endif
+
+stb_malloc_record *stb__allocations;
+static int stb__alloc_size, stb__alloc_limit, stb__alloc_mask;
+int stb__alloc_count;
+
+stb_malloc_record stb__alloc_history[STB_MALLOC_HISTORY_COUNT];
+int stb__history_pos;
+
+static int stb__hashfind(void *p)
+{
+   stb_uint32 h = stb_hashptr(p);
+   int s,n = h & stb__alloc_mask;
+   if (stb__allocations[n].p == p)
+      return n;
+   s = stb_rehash(h)|1;
+   for(;;) {
+      if (stb__allocations[n].p == NULL)
+         return -1;
+      n = (n+s) & stb__alloc_mask;
+      if (stb__allocations[n].p == p)
+         return n;
+   }
+}
+
+int stb_wrapper_allocsize(void *p)
+{
+   int n = stb__hashfind(p);
+   if (n < 0) return 0;
+   return stb__allocations[n].size;
+}
+
+static int stb__historyfind(void *p)
+{
+   int n = stb__history_pos;
+   int i;
+   for (i=0; i < STB_MALLOC_HISTORY_COUNT; ++i) {
+      if (--n < 0) n = STB_MALLOC_HISTORY_COUNT-1;
+      if (stb__alloc_history[n].p == p)
+         return n;
+   }
+   return -1;
+}
+
+static void stb__add_alloc(void *p, int sz, char *file, int line);
+static void stb__grow_alloc(void)
+{
+   int i,old_num = stb__alloc_size;
+   stb_malloc_record *old = stb__allocations;
+   if (stb__alloc_size == 0)
+      stb__alloc_size = 64;
+   else
+      stb__alloc_size *= 2;
+
+   stb__allocations = (stb_malloc_record *) stb__realloc_raw(NULL, stb__alloc_size * sizeof(stb__allocations[0]));
+   if (stb__allocations == NULL)
+      stb_fatal("Internal error: couldn't grow malloc wrapper table");
+   memset(stb__allocations, 0, stb__alloc_size * sizeof(stb__allocations[0]));
+   stb__alloc_limit = (stb__alloc_size*3)>>2;
+   stb__alloc_mask = stb__alloc_size-1;
+
+   stb__alloc_count = 0;
+
+   for (i=0; i < old_num; ++i)
+      if (old[i].p > STB_DEL) {
+         stb__add_alloc(old[i].p, old[i].size, old[i].file, old[i].line);
+         assert(stb__hashfind(old[i].p) >= 0);
+      }
+   for (i=0; i < old_num; ++i)
+      if (old[i].p > STB_DEL)
+         assert(stb__hashfind(old[i].p) >= 0);
+   stb__realloc_raw(old, 0);
+}
+
+static void stb__add_alloc(void *p, int sz, char *file, int line)
+{
+   stb_uint32 h;
+   int n, f=-1;
+   if (stb__alloc_count >= stb__alloc_limit)
+      stb__grow_alloc();
+   h = stb_hashptr(p);
+   n = h & stb__alloc_mask;
+   if (stb__allocations[n].p > STB_DEL) {
+      int s = stb_rehash(h)|1;
+      do {
+         n = (n+s) & stb__alloc_mask;
+      } while (stb__allocations[n].p > STB_DEL);
+   }
+   assert(stb__allocations[n].p == NULL || stb__allocations[n].p == STB_DEL);
+   stb__allocations[n].p = p;
+   stb__allocations[n].size = sz;
+   stb__allocations[n].line = line;
+   stb__allocations[n].file = file;
+   ++stb__alloc_count;
+}
+
+static void stb__remove_alloc(int n, char *file, int line)
+{
+   stb__alloc_history[stb__history_pos] = stb__allocations[n];
+   stb__alloc_history[stb__history_pos].file = file;
+   stb__alloc_history[stb__history_pos].line = line;
+   if (++stb__history_pos == STB_MALLOC_HISTORY_COUNT)
+      stb__history_pos = 0;
+   stb__allocations[n].p = STB_DEL;
+   --stb__alloc_count;
+}
+
+void stb_wrapper_malloc(void *p, int sz, char *file, int line)
+{
+   if (!p) return;
+   stb__add_alloc(p,sz,file,line);
+}
+
+void stb_wrapper_free(void *p, char *file, int line)
+{
+   int n;
+   
+   if (p == NULL) return;
+
+   n = stb__hashfind(p);
+
+   if (n >= 0)
+      stb__remove_alloc(n, file, line);
+   else {
+      // tried to free something we hadn't allocated!
+      n = stb__historyfind(p);
+      assert(0); /* NOTREACHED */
+      if (n >= 0)
+         stb_fatal("Attempted to free %d-byte block %p at %s:%d previously freed/realloced at %s:%d",
+                       stb__alloc_history[n].size, p,
+                       file, line,
+                       stb__alloc_history[n].file, stb__alloc_history[n].line);
+      else
+         stb_fatal("Attempted to free unknown block %p at %s:%d", p, file,line);
+   }
+}
+
+void stb_wrapper_check(void *p)
+{
+   int n;
+   
+   if (p == NULL) return;
+
+   n = stb__hashfind(p);
+
+   if (n >= 0) return;
+
+   for (n=0; n < stb__alloc_size; ++n)
+      if (stb__allocations[n].p == p)
+         stb_fatal("Internal error: pointer %p was allocated, but hash search failed", p);
+
+   // tried to free something that wasn't allocated!
+   n = stb__historyfind(p);
+   if (n >= 0)
+      stb_fatal("Checked %d-byte block %p previously freed/realloced at %s:%d",
+                    stb__alloc_history[n].size, p,
+                    stb__alloc_history[n].file, stb__alloc_history[n].line);
+   stb_fatal("Checked unknown block %p");
+}
+
+void stb_wrapper_realloc(void *p, void *q, int sz, char *file, int line)
+{
+   int n;
+   if (p == NULL) { stb_wrapper_malloc(q, sz, file, line); return; }
+   if (q == NULL) return; // nothing happened
+
+   n = stb__hashfind(p);
+   if (n == -1) {
+      // tried to free something we hadn't allocated!
+      // this is weird, though, because we got past the realloc!
+      n = stb__historyfind(p);
+      assert(0); /* NOTREACHED */
+      if (n >= 0)
+         stb_fatal("Attempted to realloc %d-byte block %p at %s:%d previously freed/realloced at %s:%d",
+                       stb__alloc_history[n].size, p,
+                       file, line,
+                       stb__alloc_history[n].file, stb__alloc_history[n].line);
+      else
+         stb_fatal("Attempted to realloc unknown block %p at %s:%d", p, file,line);
+   } else {
+      if (q == p) {
+         stb__allocations[n].size = sz;
+         stb__allocations[n].file = file;
+         stb__allocations[n].line = line;
+      } else {
+         stb__remove_alloc(n, file, line);
+         stb__add_alloc(q,sz,file,line);
+      }
+   }
+}
+
+void stb_wrapper_listall(void (*func)(void *ptr, int sz, char *file, int line))
+{
+   int i;
+   for (i=0; i < stb__alloc_size; ++i)
+      if (stb__allocations[i].p > STB_DEL)
+         func(stb__allocations[i].p   , stb__allocations[i].size,
+              stb__allocations[i].file, stb__allocations[i].line);
+}
+
+void stb_wrapper_dump(char *filename)
+{
+   int i;
+   FILE *f = fopen(filename, "w");
+   if (!f) return;
+   for (i=0; i < stb__alloc_size; ++i)
+      if (stb__allocations[i].p > STB_DEL)
+         fprintf(f, "%p %7d - %4d %s\n",
+            stb__allocations[i].p   , stb__allocations[i].size,
+            stb__allocations[i].line, stb__allocations[i].file);
+}
+#endif // STB_DEFINE
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                  stb_pointer_set
+//
+//
+// For data structures that support querying by key, data structure
+// classes always hand-wave away the issue of what to do if two entries
+// have the same key: basically, store a linked list of all the nodes
+// which have the same key (a LISP-style list).
+//
+// The thing is, it's not that trivial. If you have an O(log n)
+// lookup data structure, but then n/4 items have the same value,
+// you don't want to spend O(n) time scanning that list when
+// deleting an item if you already have a pointer to the item.
+// (You have to spend O(n) time enumerating all the items with
+// a given key, sure, and you can't accelerate deleting a particular
+// item if you only have the key, not a pointer to the item.)
+//
+// I'm going to call this data structure, whatever it turns out to
+// be, a "pointer set", because we don't store any associated data for
+// items in this data structure, we just answer the question of
+// whether an item is in it or not (it's effectively one bit per pointer).
+// Technically they don't have to be pointers; you could cast ints
+// to (void *) if you want, but you can't store 0 or 1 because of the
+// hash table.
+//
+// Since the fastest data structure we might want to add support for
+// identical-keys to is a hash table with O(1)-ish lookup time,
+// that means that the conceptual "linked list of all items with
+// the same indexed value" that we build needs to have the same
+// performance; that way when we index a table we think is arbitrary
+// ints, but in fact half of them are 0, we don't get screwed.
+//
+// Therefore, it needs to be a hash table, at least when it gets
+// large. On the other hand, when the data has totally arbitrary ints
+// or floats, there won't be many collisions, and we'll have tons of
+// 1-item bitmaps. That will be grossly inefficient as hash tables;
+// trade-off; the hash table is reasonably efficient per-item when
+// it's large, but not when it's small. So we need to do something
+// Judy-like and use different strategies depending on the size.
+//
+// Like Judy, we'll use the bottom bit to encode the strategy:
+//
+//      bottom bits:
+//          00     -   direct pointer
+//          01     -   4-item bucket (16 bytes, no length, NULLs)
+//          10     -   N-item array
+//          11     -   hash table
+
+typedef struct stb_ps stb_ps;
+
+STB_EXTERN int      stb_ps_find  (stb_ps *ps, void *value);
+STB_EXTERN stb_ps * stb_ps_add   (stb_ps *ps, void *value);
+STB_EXTERN stb_ps * stb_ps_remove(stb_ps *ps, void *value);
+STB_EXTERN stb_ps * stb_ps_remove_any(stb_ps *ps, void **value);
+STB_EXTERN void     stb_ps_delete(stb_ps *ps);
+STB_EXTERN int      stb_ps_count (stb_ps *ps);
+
+STB_EXTERN stb_ps * stb_ps_copy  (stb_ps *ps);
+STB_EXTERN int      stb_ps_subset(stb_ps *bigger, stb_ps *smaller);
+STB_EXTERN int      stb_ps_eq    (stb_ps *p0, stb_ps *p1);
+
+STB_EXTERN void ** stb_ps_getlist  (stb_ps *ps, int *count);
+STB_EXTERN int     stb_ps_writelist(stb_ps *ps, void **list, int size );
+
+// enum and fastlist don't allocate storage, but you must consume the
+// list before there's any chance the data structure gets screwed up;
+STB_EXTERN int     stb_ps_enum     (stb_ps *ps, void *data,
+                                       int (*func)(void *value, void*data) );
+STB_EXTERN void ** stb_ps_fastlist(stb_ps *ps, int *count);
+//  result:
+//     returns a list, *count is the length of that list,
+//     but some entries of the list may be invalid;
+//     test with 'stb_ps_fastlist_valid(x)'
+
+#define stb_ps_fastlist_valid(x)   ((unsigned int) (x) > 1)
+
+#ifdef STB_DEFINE
+
+enum
+{
+   STB_ps_direct = 0,
+   STB_ps_bucket = 1,
+   STB_ps_array  = 2,
+   STB_ps_hash   = 3,
+};
+
+#define STB_BUCKET_SIZE  4
+
+typedef struct
+{
+   void *p[STB_BUCKET_SIZE];
+} stb_ps_bucket;
+#define GetBucket(p)    ((stb_ps_bucket *) ((char *) (p) - STB_ps_bucket))
+#define EncodeBucket(p) ((stb_ps *) ((char *) (p) + STB_ps_bucket))
+
+typedef char stb__verify_bucket_heap_size[sizeof(stb_ps_bucket) == 16];
+
+static void stb_bucket_free(stb_ps_bucket *b)
+{
+   free(b);
+}
+
+static stb_ps_bucket *stb_bucket_create2(void *v0, void *v1)
+{
+   stb_ps_bucket *b = (stb_ps_bucket*) malloc(sizeof(*b));
+   b->p[0] = v0;
+   b->p[1] = v1;
+   b->p[2] = NULL;
+   b->p[3] = NULL;
+   return b;
+}
+
+static stb_ps_bucket * stb_bucket_create3(void **v)
+{
+   stb_ps_bucket *b = (stb_ps_bucket*) malloc(sizeof(*b));
+   b->p[0] = v[0];
+   b->p[1] = v[1];
+   b->p[2] = v[2];
+   b->p[3] = NULL;
+   return b;
+}
+
+
+// could use stb_arr, but this will save us memory
+typedef struct
+{
+   int count;
+   void *p[1];
+} stb_ps_array;
+#define GetArray(p)     ((stb_ps_array *) ((char *) (p) - STB_ps_array))
+#define EncodeArray(p)  ((stb_ps *) ((char *) (p) + STB_ps_array))
+
+static int stb_ps_array_max = 13;
+
+typedef struct
+{
+   int size, mask;
+   int count, count_deletes;
+   int grow_threshhold;
+   int shrink_threshhold;
+   int rehash_threshhold;
+   int any_offset;
+   void *table[1];
+} stb_ps_hash;
+#define GetHash(p)      ((stb_ps_hash *) ((char *) (p) - STB_ps_hash))
+#define EncodeHash(p)   ((stb_ps *) ((char *) (p) + STB_ps_hash))
+
+#define stb_ps_empty(v)   (((stb_uint32) v) <= 1)
+
+static stb_ps_hash *stb_ps_makehash(int size, int old_size, void **old_data)
+{
+   int i;
+   stb_ps_hash *h = (stb_ps_hash *) malloc(sizeof(*h) + (size-1) * sizeof(h->table[0]));
+   assert(stb_is_pow2(size));
+   h->size = size;
+   h->mask = size-1;
+   h->shrink_threshhold = (int) (0.3f * size);
+   h->  grow_threshhold = (int) (0.8f * size);
+   h->rehash_threshhold = (int) (0.9f * size);
+   h->count = 0;
+   h->count_deletes = 0;
+   h->any_offset = 0;
+   memset(h->table, 0, size * sizeof(h->table[0]));
+   for (i=0; i < old_size; ++i)
+      if (!stb_ps_empty(old_data[i]))
+         stb_ps_add(EncodeHash(h), old_data[i]);
+   return h;
+}
+
+void stb_ps_delete(stb_ps *ps)
+{
+   switch (3 & (int) ps) {
+      case STB_ps_direct: break;
+      case STB_ps_bucket: stb_bucket_free(GetBucket(ps)); break;
+      case STB_ps_array : free(GetArray(ps)); break;
+      case STB_ps_hash  : free(GetHash(ps)); break;
+   }
+}
+
+stb_ps *stb_ps_copy(stb_ps *ps)
+{
+   int i;
+   // not a switch: order based on expected performance/power-law distribution
+   switch (3 & (int) ps) {
+      case STB_ps_direct: return ps;
+      case STB_ps_bucket: {
+         stb_ps_bucket *n = (stb_ps_bucket *) malloc(sizeof(*n));
+         *n = *GetBucket(ps);
+         return EncodeBucket(n);
+      }
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         stb_ps_array *n = (stb_ps_array *) malloc(sizeof(*n) + stb_ps_array_max * sizeof(n->p[0]));
+         n->count = a->count;
+         for (i=0; i < a->count; ++i)
+            n->p[i] = a->p[i];
+         return EncodeArray(n);
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         stb_ps_hash *n = stb_ps_makehash(h->size, h->size, h->table);
+         return EncodeHash(n);
+      }
+   }
+   assert(0); /* NOTREACHED */
+   return NULL;
+}
+
+int stb_ps_find(stb_ps *ps, void *value)
+{
+   int i, code = 3 & (int) ps;
+    assert((3 & (int) value) == STB_ps_direct);
+   assert(stb_ps_fastlist_valid(value));
+   // not a switch: order based on expected performance/power-law distribution
+   if (code == STB_ps_direct)
+      return value == ps;
+   if (code == STB_ps_bucket) {
+      stb_ps_bucket *b = GetBucket(ps);
+      assert(STB_BUCKET_SIZE == 4);
+      if (b->p[0] == value || b->p[1] == value ||
+          b->p[2] == value || b->p[3] == value)
+          return STB_TRUE;
+      return STB_FALSE;
+   }
+   if (code == STB_ps_array) {
+      stb_ps_array *a = GetArray(ps);
+      for (i=0; i < a->count; ++i)
+         if (a->p[i] == value)
+            return STB_TRUE;
+      return STB_FALSE;
+   } else {
+      stb_ps_hash *h = GetHash(ps);
+      stb_uint32 hash = stb_hashptr(value);
+      stb_uint32 s, n = hash & h->mask;
+      void **t = h->table;
+      if (t[n] == value) return STB_TRUE;
+      if (t[n] == NULL) return STB_FALSE;
+      s = stb_rehash(hash) | 1;
+      do {
+         n = (n + s) & h->mask;
+         if (t[n] == value) return STB_TRUE;
+      } while (t[n] != NULL);
+      return STB_FALSE;
+   }
+}
+
+stb_ps *  stb_ps_add   (stb_ps *ps, void *value)
+{
+   #ifdef STB_DEBUG
+   assert(!stb_ps_find(ps,value));
+   #endif
+   if (value == NULL) return ps; // ignore NULL adds to avoid bad breakage
+   assert((3 & (int) value) == STB_ps_direct);
+   assert(stb_ps_fastlist_valid(value));
+   assert(value != STB_DEL);     // STB_DEL is less likely
+
+   switch (3 & (int) ps) {
+      case STB_ps_direct:
+         if (ps == NULL) return (stb_ps *) value;
+         return EncodeBucket(stb_bucket_create2(ps,value));
+
+      case STB_ps_bucket: {
+         stb_ps_bucket *b = GetBucket(ps);
+         stb_ps_array  *a;
+         assert(STB_BUCKET_SIZE == 4);
+         if (b->p[0] == NULL) { b->p[0] = value; return ps; }
+         if (b->p[1] == NULL) { b->p[1] = value; return ps; }
+         if (b->p[2] == NULL) { b->p[2] = value; return ps; }
+         if (b->p[3] == NULL) { b->p[3] = value; return ps; }
+         a = (stb_ps_array *) malloc(sizeof(*a) + 7 * sizeof(a->p[0])); // 8 slots, must be 2^k
+         memcpy(a->p, b, sizeof(*b));
+         a->p[4] = value;
+         a->count = 5;
+         stb_bucket_free(b);
+         return EncodeArray(a);
+      }
+
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         if (a->count == stb_ps_array_max) {
+            // promote from array to hash
+            stb_ps_hash *h = stb_ps_makehash(2 << stb_log2_ceil(a->count), a->count, a->p);
+            free(a);
+            return stb_ps_add(EncodeHash(h), value);
+         }
+         // do we need to resize the array? the array doubles in size when it
+         // crosses a power-of-two
+         if ((a->count & (a->count-1))==0) {
+            int newsize = a->count*2;
+            // clamp newsize to max if:
+            //    1. it's larger than max
+            //    2. newsize*1.5 is larger than max (to avoid extra resizing)
+            if (newsize + a->count > stb_ps_array_max)
+               newsize = stb_ps_array_max;
+            a = (stb_ps_array *) realloc(a, sizeof(*a) + (newsize-1) * sizeof(a->p[0]));
+         }
+         a->p[a->count++] = value;
+         return EncodeArray(a);
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         stb_uint32 hash = stb_hashptr(value);
+         stb_uint32 n = hash & h->mask;
+         void **t = h->table;
+         // find first NULL or STB_DEL entry
+         if (!stb_ps_empty(t[n])) {
+            stb_uint32 s = stb_rehash(hash) | 1;
+            do {
+               n = (n + s) & h->mask;
+            } while (!stb_ps_empty(t[n]));
+         }
+         if (t[n] == STB_DEL)
+            -- h->count_deletes;
+         t[n] = value;
+         ++ h->count;
+         if (h->count == h->grow_threshhold) {
+            stb_ps_hash *h2 = stb_ps_makehash(h->size*2, h->size, t);
+            free(h);
+            return EncodeHash(h2);
+         }
+         if (h->count + h->count_deletes == h->rehash_threshhold) {
+            stb_ps_hash *h2 = stb_ps_makehash(h->size, h->size, t);
+            free(h);
+            return EncodeHash(h2);
+         }
+         return ps;
+      }
+   }
+   return NULL; /* NOTREACHED */
+}
+
+stb_ps *stb_ps_remove(stb_ps *ps, void *value)
+{
+   #ifdef STB_DEBUG
+   assert(stb_ps_find(ps, value));
+   #endif
+   assert((3 & (int) value) == STB_ps_direct);
+   if (value == NULL) return ps; // ignore NULL removes to avoid bad breakage
+   switch (3 & (int) ps) {
+      case STB_ps_direct:
+         return ps == value ? NULL : ps;
+      case STB_ps_bucket: {
+         stb_ps_bucket *b = GetBucket(ps);
+         int count=0;
+         assert(STB_BUCKET_SIZE == 4);
+         if (b->p[0] == value) b->p[0] = NULL; else count += (b->p[0] != NULL);
+         if (b->p[1] == value) b->p[1] = NULL; else count += (b->p[1] != NULL);
+         if (b->p[2] == value) b->p[2] = NULL; else count += (b->p[2] != NULL);
+         if (b->p[3] == value) b->p[3] = NULL; else count += (b->p[3] != NULL);
+         if (count == 1) { // shrink bucket at size 1
+            value = b->p[0];
+            if (value == NULL) value = b->p[1];
+            if (value == NULL) value = b->p[2];
+            if (value == NULL) value = b->p[3];
+            assert(value != NULL);
+            stb_bucket_free(b);
+            return (stb_ps *) value; // return STB_ps_direct of value
+         }
+         return ps;
+      }
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         int i;
+         for (i=0; i < a->count; ++i) {
+            if (a->p[i] == value) {
+               a->p[i] = a->p[--a->count];
+               if (a->count == 3) { // shrink to bucket!
+                  stb_ps_bucket *b = stb_bucket_create3(a->p);
+                  free(a);
+                  return EncodeBucket(b);
+               }
+               return ps;
+            }
+         }
+         return ps;
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         stb_uint32 hash = stb_hashptr(value);
+         stb_uint32 s, n = hash & h->mask;
+         void **t = h->table;
+         if (t[n] != value) {
+            s = stb_rehash(hash) | 1;
+            do {
+               n = (n + s) & h->mask;
+            } while (t[n] != value);
+         }
+         t[n] = STB_DEL;
+         -- h->count;
+         ++ h->count_deletes;
+         // should we shrink down to an array?
+         if (h->count < stb_ps_array_max) {
+            int n = 1 << stb_log2_floor(stb_ps_array_max);
+            if (h->count < n) {
+               stb_ps_array *a = (stb_ps_array *) malloc(sizeof(*a) + (n-1) * sizeof(a->p[0]));
+               int i,j=0;
+               for (i=0; i < h->size; ++i)
+                  if (!stb_ps_empty(t[i]))
+                     a->p[j++] = t[i];
+               assert(j == h->count);
+               a->count = j;
+               free(h);
+               return EncodeArray(a);
+            }
+         }
+         if (h->count == h->shrink_threshhold) {
+            stb_ps_hash *h2 = stb_ps_makehash(h->size >> 1, h->size, t);
+            free(h);
+            return EncodeHash(h2);
+         }
+         return ps;
+      }
+   }
+   return ps; /* NOTREACHED */
+}
+
+stb_ps *stb_ps_remove_any(stb_ps *ps, void **value)
+{
+   assert(ps != NULL);
+   switch (3 & (int) ps) {
+      case STB_ps_direct:
+         *value = ps;
+         return NULL;
+      case STB_ps_bucket: {
+         stb_ps_bucket *b = GetBucket(ps);
+         int count=0, slast=0, last=0;
+         assert(STB_BUCKET_SIZE == 4);
+         if (b->p[0]) { ++count;               last = 0; }
+         if (b->p[1]) { ++count; slast = last; last = 1; }
+         if (b->p[2]) { ++count; slast = last; last = 2; }
+         if (b->p[3]) { ++count; slast = last; last = 3; }
+         *value = b->p[last];
+         b->p[last] = 0;
+         if (count == 2) {
+            void *leftover = b->p[slast]; // second to last
+            stb_bucket_free(b);
+            return (stb_ps *) leftover; 
+         }
+         return ps;
+      }
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         *value = a->p[a->count-1];
+         if (a->count == 4)
+            return stb_ps_remove(ps, *value);
+         --a->count;
+         return ps;
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         void **t = h->table;
+         stb_uint32 n = h->any_offset;
+         while (stb_ps_empty(t[n]))
+            n = (n + 1) & h->mask;
+         *value = t[n];
+         h->any_offset = (n+1) & h->mask;
+         // check if we need to skip down to the previous type
+         if (h->count-1 < stb_ps_array_max || h->count-1 == h->shrink_threshhold)
+            return stb_ps_remove(ps, *value);
+         t[n] = STB_DEL;
+         -- h->count;
+         ++ h->count_deletes;
+         return ps;
+      }
+   }
+   return ps; /* NOTREACHED */
+}
+
+
+void ** stb_ps_getlist(stb_ps *ps, int *count)
+{
+   int i,n=0;
+   void **p;
+   switch (3 & (int) ps) {
+      case STB_ps_direct:
+         if (ps == NULL) { *count = 0; return NULL; }
+         p = (void **) malloc(sizeof(*p) * 1);
+         p[0] = ps;
+         *count = 1;
+         return p;
+      case STB_ps_bucket: {
+         stb_ps_bucket *b = GetBucket(ps);
+         p = (void **) malloc(sizeof(*p) * STB_BUCKET_SIZE);
+         for (i=0; i < STB_BUCKET_SIZE; ++i)
+            if (b->p[i] != NULL)
+               p[n++] = b->p[i];
+         break;
+      }
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         p = (void **) malloc(sizeof(*p) * a->count);
+         memcpy(p, a->p, sizeof(*p) * a->count);
+         *count = a->count;
+         return p;
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         p = (void **) malloc(sizeof(*p) * h->count);
+         for (i=0; i < h->size; ++i)
+            if (!stb_ps_empty(h->table[i]))
+               p[n++] = h->table[i];
+         break;
+      }
+   }
+   *count = n;
+   return p;
+}
+
+int stb_ps_writelist(stb_ps *ps, void **list, int size )
+{
+   int i,n=0;
+   switch (3 & (int) ps) {
+      case STB_ps_direct:
+         if (ps == NULL || size <= 0) return 0;
+         list[0] = ps;
+         return 1;
+      case STB_ps_bucket: {
+         stb_ps_bucket *b = GetBucket(ps);
+         for (i=0; i < STB_BUCKET_SIZE; ++i)
+            if (b->p[i] != NULL && n < size)
+               list[n++] = b->p[i];
+         return n;
+      }
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         n = stb_min(size, a->count);
+         memcpy(list, a->p, sizeof(*list) * n);
+         return n;
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         if (size <= 0) return 0;
+         for (i=0; i < h->count; ++i) {
+            if (!stb_ps_empty(h->table[i])) {
+               list[n++] = h->table[i];
+               if (n == size) break;
+            }
+         }
+         return n;
+      }
+   }
+   return 0; /* NOTREACHED */
+}
+
+int stb_ps_enum(stb_ps *ps, void *data, int (*func)(void *value, void *data))
+{
+   int i;
+   switch (3 & (int) ps) {
+      case STB_ps_direct:
+         if (ps == NULL) return STB_TRUE;
+         return func(ps, data);
+      case STB_ps_bucket: {
+         stb_ps_bucket *b = GetBucket(ps);
+         for (i=0; i < STB_BUCKET_SIZE; ++i)
+            if (b->p[i] != NULL)
+               if (!func(b->p[i], data))
+                  return STB_FALSE;
+         return STB_TRUE;
+      }
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         for (i=0; i < a->count; ++i)
+            if (!func(a->p[i], data))
+               return STB_FALSE;
+         return STB_TRUE;
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         for (i=0; i < h->count; ++i)
+            if (!stb_ps_empty(h->table[i]))
+               if (!func(h->table[i], data))
+                  return STB_FALSE;
+         return STB_TRUE;
+      }
+   }
+   return STB_TRUE; /* NOTREACHED */
+}
+
+int stb_ps_count (stb_ps *ps)
+{
+   switch (3 & (int) ps) {
+      case STB_ps_direct:
+         return ps != NULL;
+      case STB_ps_bucket: {
+         stb_ps_bucket *b = GetBucket(ps);
+         return (b->p[0] != NULL) + (b->p[1] != NULL) +
+                (b->p[2] != NULL) + (b->p[3] != NULL);
+      }
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         return a->count;
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         return h->count;
+      }
+   }
+   return 0;
+}
+
+void ** stb_ps_fastlist(stb_ps *ps, int *count)
+{
+   static void *storage;
+
+   switch (3 & (int) ps) {
+      case STB_ps_direct:
+         if (ps == NULL) { *count = 0; return NULL; }
+         storage = ps;
+         *count = 1;
+         return &storage;
+      case STB_ps_bucket: {
+         stb_ps_bucket *b = GetBucket(ps);
+         *count = STB_BUCKET_SIZE;
+         return b->p;
+      }
+      case STB_ps_array: {
+         stb_ps_array *a = GetArray(ps);
+         *count = a->count;
+         return a->p;
+      }
+      case STB_ps_hash: {
+         stb_ps_hash *h = GetHash(ps);
+         *count = h->size;
+         return h->table;
+      }
+   }
+   return NULL; /* NOTREACHED */
+}
+
+int stb_ps_subset(stb_ps *bigger, stb_ps *smaller)
+{
+   int i, listlen;
+   void **list = stb_ps_fastlist(smaller, &listlen);
+   for(i=0; i < listlen; ++i)
+      if (stb_ps_fastlist_valid(list[i]))
+         if (!stb_ps_find(bigger, list[i]))
+            return 0;
+   return 1;
+}
+
+int stb_ps_eq(stb_ps *p0, stb_ps *p1)
+{
+   if (stb_ps_count(p0) != stb_ps_count(p1))
+      return 0;
+   return stb_ps_subset(p0, p1);
+}
+
+#undef GetBucket
+#undef GetArray
+#undef GetHash
+
+#undef EncodeBucket
+#undef EncodeArray
+#undef EncodeHash
+
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//               Random Numbers via Meresenne Twister or LCG
+//
+
+STB_EXTERN unsigned long stb_srandLCG(unsigned long seed);
+STB_EXTERN unsigned long stb_randLCG(void);
+STB_EXTERN double        stb_frandLCG(void);
+
+STB_EXTERN void          stb_srand(unsigned long seed);
+STB_EXTERN unsigned long stb_rand(void);
+STB_EXTERN double        stb_frand(void);
+STB_EXTERN void          stb_shuffle(void *p, size_t n, size_t sz,
+                                        unsigned long seed);
+STB_EXTERN void stb_reverse(void *p, size_t n, size_t sz);
+
+STB_EXTERN unsigned long stb_randLCG_explicit(unsigned long seed);
+
+#define stb_rand_define(x,y)                                         \
+                                                                     \
+   unsigned long x(void)                                             \
+   {                                                                 \
+      static unsigned long stb__rand = y;                            \
+      stb__rand = stb__rand * 2147001325 + 715136305; /* BCPL */     \
+      return 0x31415926 ^ ((stb__rand >> 16) + (stb__rand << 16));   \
+   }
+
+#ifdef STB_DEFINE
+unsigned long stb_randLCG_explicit(unsigned long seed)
+{
+   return seed * 2147001325 + 715136305;
+}
+
+static unsigned long stb__rand_seed=0;
+
+unsigned long stb_srandLCG(unsigned long seed)
+{
+   unsigned long previous = stb__rand_seed;
+   stb__rand_seed = seed;
+   return previous;
+}
+
+unsigned long stb_randLCG(void)
+{
+   stb__rand_seed = stb__rand_seed * 2147001325 + 715136305; // BCPL generator
+   // shuffle non-random bits to the middle, and xor to decorrelate with seed
+   return 0x31415926 ^ ((stb__rand_seed >> 16) + (stb__rand_seed << 16));
+}
+
+double stb_frandLCG(void)
+{
+   return stb_randLCG() / ((double) (1 << 16) * (1 << 16));
+}
+
+void stb_shuffle(void *p, size_t n, size_t sz, unsigned long seed)
+{
+   char *a;
+   unsigned long old_seed;
+   int i;
+   if (seed)
+      old_seed = stb_srandLCG(seed);
+   a = (char *) p + (n-1) * sz;
+
+   for (i=n; i > 1; --i) {
+      int j = stb_randLCG() % i;
+      stb_swap(a, (char *) p + j * sz, sz);
+      a -= sz;
+   }
+   if (seed)
+      stb_srandLCG(old_seed);
+}
+
+void stb_reverse(void *p, size_t n, size_t sz)
+{
+   int i,j = n-1;
+   for (i=0; i < j; ++i,--j) {
+      stb_swap((char *) p + i * sz, (char *) p + j * sz, sz);
+   }
+}
+
+// public domain Mersenne Twister by Michael Brundage
+#define STB__MT_LEN       624
+
+int stb__mt_index = STB__MT_LEN*sizeof(unsigned long)+1;
+unsigned long stb__mt_buffer[STB__MT_LEN];
+
+void stb_srand(unsigned long seed)
+{
+   int i;
+   unsigned long old = stb_srandLCG(seed);
+   for (i = 0; i < STB__MT_LEN; i++)
+      stb__mt_buffer[i] = stb_randLCG();
+   stb_srandLCG(old);
+   stb__mt_index = STB__MT_LEN*sizeof(unsigned long);
+}
+
+#define STB__MT_IA           397
+#define STB__MT_IB           (STB__MT_LEN - STB__MT_IA)
+#define STB__UPPER_MASK      0x80000000
+#define STB__LOWER_MASK      0x7FFFFFFF
+#define STB__MATRIX_A        0x9908B0DF
+#define STB__TWIST(b,i,j)    ((b)[i] & STB__UPPER_MASK) | ((b)[j] & STB__LOWER_MASK)
+#define STB__MAGIC(s)        (((s)&1)*STB__MATRIX_A)
+
+unsigned long stb_rand()
+{
+   unsigned long * b = stb__mt_buffer;
+   int idx = stb__mt_index;
+   unsigned long s,r;
+   int i;
+	
+   if (idx >= STB__MT_LEN*sizeof(unsigned long)) {
+      if (idx > STB__MT_LEN*sizeof(unsigned long))
+         stb_srand(0);
+      idx = 0;
+      i = 0;
+      for (; i < STB__MT_IB; i++) {
+         s = STB__TWIST(b, i, i+1);
+         b[i] = b[i + STB__MT_IA] ^ (s >> 1) ^ STB__MAGIC(s);
+      }
+      for (; i < STB__MT_LEN-1; i++) {
+         s = STB__TWIST(b, i, i+1);
+         b[i] = b[i - STB__MT_IB] ^ (s >> 1) ^ STB__MAGIC(s);
+      }
+      
+      s = STB__TWIST(b, STB__MT_LEN-1, 0);
+      b[STB__MT_LEN-1] = b[STB__MT_IA-1] ^ (s >> 1) ^ STB__MAGIC(s);
+   }
+   stb__mt_index = idx + sizeof(unsigned long);
+   
+   r = *(unsigned long *)((unsigned char *)b + idx);
+   
+   r ^= (r >> 11);
+   r ^= (r << 7) & 0x9D2C5680;
+   r ^= (r << 15) & 0xEFC60000;
+   r ^= (r >> 18);
+   
+   return r;
+}
+
+double stb_frand(void)
+{
+   return stb_rand() / ((double) (1 << 16) * (1 << 16));
+}
+
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                        stb_dupe
+//
+// stb_dupe is a duplicate-finding system for very, very large data
+// structures--large enough that sorting is too slow, but not so large
+// that we can't keep all the data in memory. using it works as follows:
+//
+//     1. create an stb_dupe:
+//          provide a hash function
+//          provide an equality function
+//          provide an estimate for the size
+//          optionally provide a comparison function
+//
+//     2. traverse your data, 'adding' pointers to the stb_dupe
+//
+//     3. finish and ask for duplicates
+//
+//        the stb_dupe will discard its intermediate data and build
+//        a collection of sorted lists of duplicates, with non-duplicate
+//        entries omitted entirely
+//
+//
+//  Implementation strategy:
+//
+//     while collecting the N items, we keep a hash table of approximate
+//     size sqrt(N). (if you tell use the N up front, the hash table is
+//     just that size exactly)
+//
+//     each entry in the hash table is just an stb__arr of pointers (no need
+//     to use stb_ps, because we don't need to delete from these)
+//
+//     for step 3, for each entry in the hash table, we apply stb_dupe to it
+//     recursively. once the size gets small enough (or doesn't decrease
+//     significantly), we switch to either using qsort() on the comparison
+//     function, or else we just do the icky N^2 gather
+
+
+typedef struct stb_dupe stb_dupe;
+
+typedef int (*stb_compare_func)(void *a, void *b);
+typedef int (*stb_hash_func)(void *a, unsigned int seed);
+
+STB_EXTERN void stb_dupe_free(stb_dupe *sd);
+STB_EXTERN stb_dupe *stb_dupe_create(stb_hash_func hash,
+                          stb_compare_func eq, int size, stb_compare_func ineq);
+STB_EXTERN void stb_dupe_add(stb_dupe *sd, void *item);
+STB_EXTERN void stb_dupe_finish(stb_dupe *sd);
+STB_EXTERN int stb_dupe_numsets(stb_dupe *sd);
+STB_EXTERN void **stb_dupe_set(stb_dupe *sd, int num);
+STB_EXTERN int stb_dupe_set_count(stb_dupe *sd, int num);
+
+struct stb_dupe
+{
+   void ***hash_table;
+   int hash_size;
+   int size_log2;
+   int population;
+
+   int hash_shift;
+   stb_hash_func     hash;
+
+   stb_compare_func  eq;
+   stb_compare_func  ineq;
+
+   void ***dupes;
+};
+
+#ifdef STB_DEFINE
+
+int stb_dupe_numsets(stb_dupe *sd)
+{
+   assert(sd->hash_table == NULL);
+   return stb_arr_len(sd->dupes);
+}
+
+void **stb_dupe_set(stb_dupe *sd, int num)
+{
+   assert(sd->hash_table == NULL);
+   return sd->dupes[num];
+}
+
+int stb_dupe_set_count(stb_dupe *sd, int num)
+{
+   assert(sd->hash_table == NULL);
+   return stb_arr_len(sd->dupes[num]);
+}
+
+stb_dupe *stb_dupe_create(stb_hash_func hash, stb_compare_func eq, int size,
+                                              stb_compare_func ineq)
+{
+   int i, hsize;
+   stb_dupe *sd = (stb_dupe *) malloc(sizeof(*sd));
+
+   sd->size_log2 = 4;
+   hsize = 1 << sd->size_log2;
+   while (hsize * hsize < size) {
+      ++sd->size_log2;
+      hsize *= 2;
+   }
+
+   sd->hash = hash;
+   sd->eq   = eq;
+   sd->ineq = ineq;
+   sd->hash_shift = 0;
+
+   sd->population = 0;
+   sd->hash_size = hsize;
+   sd->hash_table = (void ***) malloc(sizeof(*sd->hash_table) * hsize);
+   for (i=0; i < hsize; ++i)
+      sd->hash_table[i] = NULL;
+
+   sd->dupes = NULL;
+
+   return sd;
+}
+
+void stb_dupe_add(stb_dupe *sd, void *item)
+{
+   stb_uint32 hash = sd->hash(item, sd->hash_shift);
+   int z = hash & (sd->hash_size-1);
+   stb_arr_push(sd->hash_table[z], item);
+   ++sd->population;
+}
+
+void stb_dupe_free(stb_dupe *sd)
+{
+   int i;
+   for (i=0; i < stb_arr_len(sd->dupes); ++i)
+      if (sd->dupes[i])
+         stb_arr_free(sd->dupes[i]);
+   stb_arr_free(sd->dupes);
+   free(sd);
+}
+
+static stb_compare_func stb__compare;
+
+static int stb__dupe_compare(const void *a, const void *b)
+{
+   void *p = *(void **) a;
+   void *q = *(void **) b;
+
+   return stb__compare(p,q);
+}
+
+void stb_dupe_finish(stb_dupe *sd)
+{
+   int i,j,k;
+   assert(sd->dupes == NULL);
+   for (i=0; i < sd->hash_size; ++i) {
+      void ** list = sd->hash_table[i];
+      if (list != NULL) {                                          
+         int n = stb_arr_len(list);
+         // @TODO: measure to find good numbers instead of just making them up!
+         int thresh = (sd->ineq ? 200 : 20);
+         // if n is large enough to be worth it, and n is smaller than
+         // before (so we can guarantee we'll use a smaller hash table);
+         // and there are enough hash bits left, assuming full 32-bit hash
+         if (n > thresh && n < (sd->population >> 3) && sd->hash_shift + sd->size_log2*2 < 32) {
+
+            // recursively process this row using stb_dupe, O(N log log N)
+
+            stb_dupe *d = stb_dupe_create(sd->hash, sd->eq, n, sd->ineq);
+            d->hash_shift = stb_randLCG_explicit(sd->hash_shift);
+            for (j=0; j < n; ++j)
+               stb_dupe_add(d, list[j]);
+            stb_arr_free(sd->hash_table[i]);
+            stb_dupe_finish(d);
+            for (j=0; j < stb_arr_len(d->dupes); ++j) {
+               stb_arr_push(sd->dupes, d->dupes[j]);
+               d->dupes[j] = NULL; // take over ownership
+            }
+            stb_dupe_free(d);
+
+         } else if (sd->ineq) {
+
+            // process this row using qsort(), O(N log N)
+            stb__compare = sd->ineq;
+            qsort(list, n, sizeof(list[0]), stb__dupe_compare);
+
+            // find equal subsequences of the list
+            for (j=0; j < n-1; ) {
+               // find a subsequence from j..k
+               for (k=j; k < n; ++k)
+                  // only use ineq so eq can be left undefined
+                  if (sd->ineq(list[j], list[k]))
+                     break;
+               // k is the first one not in the subsequence
+               if (k-j > 1) {
+                  void **mylist = NULL;
+                  stb_arr_setlen(mylist, k-j);
+                  memcpy(mylist, list+j, sizeof(list[j]) * (k-j));
+                  stb_arr_push(sd->dupes, mylist);
+               }
+               j = k;
+            }
+            stb_arr_free(sd->hash_table[i]);
+         } else {
+
+            // process this row using eq(), O(N^2)
+            for (j=0; j < n; ++j) {
+               if (list[j] != NULL) {
+                  void **output  = NULL;
+                  for (k=j+1; k < n; ++k) {
+                     if (sd->eq(list[j], list[k])) {
+                        if (output == NULL)
+                           stb_arr_push(output, list[j]);
+                        stb_arr_push(output, list[k]);
+                        list[k] = NULL;
+                     }
+                  }
+                  list[j] = NULL;
+                  if (output)
+                     stb_arr_push(sd->dupes, output);
+               }
+            }
+            stb_arr_free(sd->hash_table[i]);
+         }
+      }
+   }
+   free(sd->hash_table);
+   sd->hash_table = NULL;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                       templatized Sort routine
+//
+// This is an attempt to implement a templated sorting algorithm.
+// To use it, you have to explicitly instantiate it as a _function_,
+// then you call that function. This allows the comparison to be inlined,
+// giving the sort similar performance to C++ sorts.
+//
+// It implements quicksort with three-way-median partitioning (generally
+// well-behaved), with a final insertion sort pass.
+//
+// When you define the compare expression, you should assume you have
+// elements of your array pointed to by 'a' and 'b', and perform the comparison
+// on those. OR you can use one or more statements; first say '0;', then
+// write whatever code you want, and compute the result into a variable 'c'.
+
+#define stb_declare_sort(FUNCNAME, TYPE)    \
+                       void FUNCNAME(TYPE *p, int n)
+#define stb_define_sort(FUNCNAME,TYPE,COMPARE) \
+                       stb__define_sort(       void, FUNCNAME,TYPE,COMPARE)
+#define stb_define_sort_static(FUNCNAME,TYPE,COMPARE) \
+                       stb__define_sort(static void, FUNCNAME,TYPE,COMPARE)
+
+#define stb__define_sort(MODE, FUNCNAME, TYPE, COMPARE)                       \
+                                                                              \
+static void STB_(FUNCNAME,_ins_sort)(TYPE *p, int n)                          \
+{                                                                             \
+   int i,j;                                                                   \
+   for (i=1; i < n; ++i) {                                                    \
+      TYPE t = p[i], *a = &t;                                                 \
+      j = i;                                                                  \
+      while (j > 0) {                                                         \
+         TYPE *b = &p[j-1];                                                   \
+         int c = COMPARE;                                                     \
+         if (!c) break;                                                       \
+         p[j] = p[j-1];                                                       \
+         --j;                                                                 \
+      }                                                                       \
+      if (i != j)                                                             \
+         p[j] = t;                                                            \
+   }                                                                          \
+}                                                                             \
+                                                                              \
+static void STB_(FUNCNAME,_quicksort)(TYPE *p, int n)                         \
+{                                                                             \
+   /* threshhold for transitioning to insertion sort */                       \
+   while (n > 12) {                                                           \
+      TYPE *a,*b,t;                                                           \
+      int c01,c12,c,m,i,j;                                                    \
+                                                                              \
+      /* compute median of three */                                           \
+      m = n >> 1;                                                             \
+      a = &p[0];                                                              \
+      b = &p[m];                                                              \
+      c = COMPARE;                                                            \
+      c01 = c;                                                                \
+      a = &p[m];                                                              \
+      b = &p[n-1];                                                            \
+      c = COMPARE;                                                            \
+      c12 = c;                                                                \
+      /* if 0 >= mid >= end, or 0 < mid < end, then use mid */                \
+      if (c01 != c12) {                                                       \
+         /* otherwise, we'll need to swap something else to middle */         \
+         int z;                                                               \
+         a = &p[0];                                                           \
+         b = &p[n-1];                                                         \
+         c = COMPARE;                                                         \
+         /* 0>mid && mid<n:  0>n => n; 0<n => 0 */                            \
+         /* 0<mid && mid>n:  0>n => 0; 0<n => n */                            \
+         z = (c == c12) ? 0 : n-1;                                            \
+         t = p[z];                                                            \
+         p[z] = p[m];                                                         \
+         p[m] = t;                                                            \
+      }                                                                       \
+      /* now p[m] is the median-of-three */                                   \
+      /* swap it to the beginning so it won't move around */                  \
+      t = p[0];                                                               \
+      p[0] = p[m];                                                            \
+      p[m] = t;                                                               \
+                                                                              \
+      /* partition loop */                                                    \
+      i=1;                                                                    \
+      j=n-1;                                                                  \
+      for(;;) {                                                               \
+         /* handling of equality is crucial here */                           \
+         /* for sentinels & efficiency with duplicates */                     \
+         b = &p[0];                                                           \
+         for (;;++i) {                                                        \
+            a=&p[i];                                                          \
+            c = COMPARE;                                                      \
+            if (!c) break;                                                    \
+         }                                                                    \
+         a = &p[0];                                                           \
+         for (;;--j) {                                                        \
+            b=&p[j];                                                          \
+            c = COMPARE;                                                      \
+            if (!c) break;                                                    \
+         }                                                                    \
+         /* make sure we haven't crossed */                                   \
+         if (i >= j) break;                                                   \
+         t = p[i];                                                            \
+         p[i] = p[j];                                                         \
+         p[j] = t;                                                            \
+                                                                              \
+         ++i;                                                                 \
+         --j;                                                                 \
+      }                                                                       \
+      /* recurse on smaller side, iterate on larger */                        \
+      if (j < (n-i)) {                                                        \
+         STB_(FUNCNAME,_quicksort)(p,j);                                       \
+         p = p+i;                                                             \
+         n = n-i;                                                             \
+      } else {                                                                \
+         STB_(FUNCNAME,_quicksort)(p+i, n-i);                                  \
+         n = j;                                                               \
+      }                                                                       \
+   }                                                                          \
+}                                                                             \
+                                                                              \
+MODE FUNCNAME(TYPE *p, int n)                                                 \
+{                                                                             \
+   STB_(FUNCNAME, _quicksort)(p, n);                                           \
+   STB_(FUNCNAME, _ins_sort)(p, n);                                            \
+}                                                                             \
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//      stb_bitset   an array of booleans indexed by integers
+//
+
+typedef stb_uint32 stb_bitset;
+
+STB_EXTERN  stb_bitset *stb_bitset_new(int value, int len);
+
+#define stb_bitset_clearall(arr,len)     (memset(arr,   0, 4 * (len)))
+#define stb_bitset_setall(arr,len)       (memset(arr, 255, 4 * (len)))
+
+#define stb_bitset_setbit(arr,n)         ((arr)[(n) >> 5] |=  (1 << (n & 31)))
+#define stb_bitset_clearbit(arr,n)       ((arr)[(n) >> 5] &= ~(1 << (n & 31)))
+#define stb_bitset_testbit(arr,n)        ((arr)[(n) >> 5] &   (1 << (n & 31)))
+
+STB_EXTERN  stb_bitset *stb_bitset_union(stb_bitset *p0, stb_bitset *p1, int len);
+
+STB_EXTERN  int *stb_bitset_getlist(stb_bitset *out, int start, int end);
+
+STB_EXTERN  int  stb_bitset_eq(stb_bitset *p0, stb_bitset *p1, int len);
+STB_EXTERN  int  stb_bitset_disjoint(stb_bitset *p0, stb_bitset *p1, int len);
+STB_EXTERN  int  stb_bitset_disjoint_0(stb_bitset *p0, stb_bitset *p1, int len);
+STB_EXTERN  int  stb_bitset_subset(stb_bitset *bigger, stb_bitset *smaller, int len);
+STB_EXTERN  int  stb_bitset_unioneq_changed(stb_bitset *p0, stb_bitset *p1, int len);
+
+#ifdef STB_DEFINE
+int stb_bitset_eq(stb_bitset *p0, stb_bitset *p1, int len)
+{
+   int i;
+   for (i=0; i < len; ++i)
+      if (p0[i] != p1[i]) return 0;
+   return 1;
+}
+
+int stb_bitset_disjoint(stb_bitset *p0, stb_bitset *p1, int len)
+{
+   int i;
+   for (i=0; i < len; ++i)
+      if (p0[i] & p1[i]) return 0;
+   return 1;
+}
+
+int stb_bitset_disjoint_0(stb_bitset *p0, stb_bitset *p1, int len)
+{
+   int i;
+   for (i=0; i < len; ++i)
+      if ((p0[i] | p1[i]) != 0xffffffff) return 0;
+   return 1;
+}
+
+int stb_bitset_subset(stb_bitset *bigger, stb_bitset *smaller, int len)
+{
+   int i;
+   for (i=0; i < len; ++i)
+      if ((bigger[i] & smaller[i]) != smaller[i]) return 0;
+   return 1;
+}
+
+stb_bitset *stb_bitset_union(stb_bitset *p0, stb_bitset *p1, int len)
+{
+   int i;
+   stb_bitset *d = (stb_bitset *) malloc(sizeof(*d) * len);
+   for (i=0; i < len; ++i) d[i] = p0[i] | p1[i];
+   return d;
+}
+
+int stb_bitset_unioneq_changed(stb_bitset *p0, stb_bitset *p1, int len)
+{
+   int i, changed=0;
+   for (i=0; i < len; ++i) {
+      stb_bitset d = p0[i] | p1[i];
+      if (d != p0[i]) {
+         p0[i] = d;
+         changed = 1;
+      }
+   }
+   return changed;
+}
+
+stb_bitset *stb_bitset_new(int value, int len)
+{
+   int i;
+   stb_bitset *d = (stb_bitset *) malloc(sizeof(*d) * len);
+   if (value) value = 0xffffffff;
+   for (i=0; i < len; ++i) d[i] = value;
+   return d;
+}
+
+int *stb_bitset_getlist(stb_bitset *out, int start, int end)
+{
+   int *list = NULL;
+   int i;
+   for (i=start; i < end; ++i)
+      if (stb_bitset_testbit(out, i))
+         stb_arr_push(list, i);
+   return list;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//      stb_wordwrap    quality word-wrapping for fixed-width fonts
+//
+
+STB_EXTERN int stb_wordwrap(int *pairs, int pair_max, int count, char *str);
+STB_EXTERN int *stb_wordwrapalloc(int count, char *str);
+
+#ifdef STB_DEFINE
+
+int stb_wordwrap(int *pairs, int pair_max, int count, char *str)
+{
+   int n=0,i=0, start=0,nonwhite=0;
+   if (pairs == NULL) pair_max = 0x7ffffff0;
+   else pair_max *= 2;
+   // parse 
+   for(;;) {
+      int s=i; // first whitespace char; last nonwhite+1
+      int w;   // word start
+      // accept whitespace
+      while (isspace(str[i])) {
+         if (str[i] == '\n' || str[i] == '\r') {
+            if (str[i] + str[i+1] == '\n' + '\r') ++i;
+            if (n >= pair_max) return -1;
+            if (pairs) pairs[n] = start, pairs[n+1] = s-start;
+            n += 2;
+            nonwhite=0;
+            start = i+1;
+            s = start;
+         }
+         ++i;
+      }
+      if (i >= start+count) {
+         // we've gone off the end using whitespace
+         if (nonwhite) {
+            if (n >= pair_max) return -1;
+            if (pairs) pairs[n] = start, pairs[n+1] = s-start;
+            n += 2;
+            start = s = i;
+            nonwhite=0;
+         } else {
+            // output all the whitespace
+            while (i >= start+count) {
+               if (n >= pair_max) return -1;
+               if (pairs) pairs[n] = start, pairs[n+1] = count;
+               n += 2;
+               start += count;
+            }
+            s = start;
+         }
+      }
+
+      if (str[i] == 0) break;
+      // now scan out a word and see if it fits
+      w = i;
+      while (str[i] && !isspace(str[i])) {
+         ++i;
+      }
+      // wrapped?
+      if (i > start + count) {
+         // huge?
+         if (i-s <= count) {
+            if (n >= pair_max) return -1;
+            if (pairs) pairs[n] = start, pairs[n+1] = s-start;
+            n += 2;
+            start = w;
+         } else {
+            // This word is longer than one line. If we wrap it onto N lines
+            // there are leftover chars. do those chars fit on the cur line?
+            // But if we have leading whitespace, we force it to start here.
+            if ((w-start) + ((i-w) % count) <= count || !nonwhite) {
+               // output a full line
+               if (n >= pair_max) return -1;
+               if (pairs) pairs[n] = start, pairs[n+1] = count;
+               n += 2;
+               start += count;
+               w = start;
+            } else {
+               // output a partial line, trimming trailing whitespace
+               if (s != start) {
+                  if (n >= pair_max) return -1;
+                  if (pairs) pairs[n] = start, pairs[n+1] = s-start;
+                  n += 2;
+                  start = w;
+               }
+            }
+            // now output full lines as needed
+            while (start + count <= i) {
+               if (n >= pair_max) return -1;
+               if (pairs) pairs[n] = start, pairs[n+1] = count;
+               n += 2;
+               start += count;
+            }
+         }
+      }
+      nonwhite=1;
+   }
+   if (start < i) {
+      if (n >= pair_max) return -1;
+      if (pairs) pairs[n] = start, pairs[n+1] = i-start;
+      n += 2;
+   }
+   return n>>1;
+}
+
+int *stb_wordwrapalloc(int count, char *str)
+{
+   int n = stb_wordwrap(NULL,0,count,str);
+   int *z = NULL;
+   stb_arr_setlen(z, n*2);
+   stb_wordwrap(z, n, count, str);
+   return z;
+}
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//         stb_match:    wildcards and regexping
+//
+
+STB_EXTERN int stb_wildmatch (char *expr, char *candidate);
+STB_EXTERN int stb_wildmatchi(char *expr, char *candidate);
+STB_EXTERN int stb_wildfind  (char *expr, char *candidate);
+STB_EXTERN int stb_wildfindi (char *expr, char *candidate);
+
+STB_EXTERN int stb_regex(char *regex, char *candidate);
+
+typedef struct stb_matcher stb_matcher;
+
+STB_EXTERN stb_matcher *stb_regex_matcher(char *regex);
+STB_EXTERN int stb_matcher_match(stb_matcher *m, char *str);
+STB_EXTERN int stb_matcher_find(stb_matcher *m, char *str);
+STB_EXTERN void stb_matcher_free(stb_matcher *f);
+
+STB_EXTERN stb_matcher *stb_lex_matcher(void);
+STB_EXTERN int stb_lex_item(stb_matcher *m, char *str, int result);
+STB_EXTERN int stb_lex_item_wild(stb_matcher *matcher, char *regex, int result);
+STB_EXTERN int stb_lex(stb_matcher *m, char *str, int *len);
+
+
+
+#ifdef STB_DEFINE
+
+static int stb__match_qstring(char *candidate, char *qstring, int qlen, int insensitive)
+{
+   int i;
+   if (insensitive) {
+      for (i=0; i < qlen; ++i)
+         if (qstring[i] == '?') {
+            if (!candidate[i]) return 0;
+         } else
+            if (tolower(qstring[i]) != tolower(candidate[i]))
+               return 0;
+   } else {
+      for (i=0; i < qlen; ++i)
+         if (qstring[i] == '?') {
+            if (!candidate[i]) return 0;
+         } else
+            if (qstring[i] != candidate[i])
+               return 0;
+   }
+   return 1;
+}
+
+static int stb__find_qstring(char *candidate, char *qstring, int qlen, int insensitive)
+{
+   char c;
+
+   int offset=0;
+   while (*qstring == '?') {
+      ++qstring;
+      --qlen;
+      ++candidate;
+      if (qlen == 0) return 0;
+      if (*candidate == 0) return -1;
+   }
+
+   c = *qstring++;
+   --qlen;
+   if (insensitive) c = tolower(c);
+
+   while (candidate[offset]) {
+      if (c == (insensitive ? tolower(candidate[offset]) : candidate[offset]))
+         if (stb__match_qstring(candidate+offset+1, qstring, qlen, insensitive))
+            return offset;
+      ++offset;
+   }
+
+   return -1;
+}
+
+int stb__wildmatch_raw2(char *expr, char *candidate, int search, int insensitive)
+{
+   int where=0;
+   int start = -1;
+   
+   if (!search) {
+      // parse to first '*'
+      if (*expr != '*')
+         start = 0;
+      while (*expr != '*') {
+         if (!*expr)
+            return *candidate == 0 ? 0 : -1;
+         if (*expr == '?') {
+            if (!*candidate) return -1;
+         } else {
+            if (insensitive) {
+               if (tolower(*candidate) != tolower(*expr))
+                  return -1;
+            } else 
+               if (*candidate != *expr)
+                  return -1;
+         }
+         ++candidate, ++expr, ++where;
+      }
+   } else {
+      // 0-length search string
+      if (!*expr)
+         return 0;
+   }
+
+   assert(search || *expr == '*');
+   if (!search)
+      ++expr;
+
+   // implicit '*' at this point
+      
+   while (*expr) {
+      int o=0;
+      // combine redundant * characters
+      while (expr[0] == '*') ++expr;
+
+      // ok, at this point, expr[-1] == '*',
+      // and expr[0] != '*'
+
+      if (!expr[0]) return start >= 0 ? start : 0;
+
+      // now find next '*'
+      o = 0;
+      while (expr[o] != '*') {
+         if (expr[o] == 0)
+            break;
+         ++o;
+      }
+      // if no '*', scan to end, then match at end
+      if (expr[o] == 0 && !search) {
+         int z;
+         for (z=0; z < o; ++z)
+            if (candidate[z] == 0)
+               return -1;
+         while (candidate[z])
+            ++z;
+         // ok, now check if they match
+         if (stb__match_qstring(candidate+z-o, expr, o, insensitive))
+            return start >= 0 ? start : 0;
+         return -1; 
+      } else {
+         // if yes '*', then do stb__find_qmatch on the intervening chars
+         int n = stb__find_qstring(candidate, expr, o, insensitive);
+         if (n < 0)
+            return -1;
+         if (start < 0)
+            start = where + n;
+         expr += o;
+         candidate += n+o;
+      }
+
+      if (*expr == 0) {
+         assert(search);
+         return start;
+      }
+
+      assert(*expr == '*');
+      ++expr;
+   }
+
+   return start >= 0 ? start : 0;
+}
+
+int stb__wildmatch_raw(char *expr, char *candidate, int search, int insensitive)
+{
+   char buffer[256];
+   // handle multiple search strings
+   char *s = strchr(expr, ';');
+   char *last = expr;
+   while (s) {
+      int z;
+      // need to allow for non-writeable strings... assume they're small
+      if (s - last < 256) {
+         stb_strncpy(buffer, last, s-last+1);
+         z = stb__wildmatch_raw2(buffer, candidate, search, insensitive);
+      } else {
+         *s = 0;
+         z = stb__wildmatch_raw2(last, candidate, search, insensitive);
+         *s = ';';
+      }
+      if (z >= 0) return z;
+      last = s+1;
+      s = strchr(last, ';');
+   }
+   return stb__wildmatch_raw2(last, candidate, search, insensitive);
+}
+
+int stb_wildmatch(char *expr, char *candidate)
+{
+   return stb__wildmatch_raw(expr, candidate, 0,0) >= 0;
+}
+
+int stb_wildmatchi(char *expr, char *candidate)
+{
+   return stb__wildmatch_raw(expr, candidate, 0,1) >= 0;
+}
+
+int stb_wildfind(char *expr, char *candidate)
+{
+   return stb__wildmatch_raw(expr, candidate, 1,0);
+}
+
+int stb_wildfindi(char *expr, char *candidate)
+{
+   return stb__wildmatch_raw(expr, candidate, 1,1);
+}
+
+typedef struct
+{
+   stb_int16 transition[256];
+} stb_dfa;
+
+// an NFA node represents a state you're in; it then has
+// an arbitrary number of edges dangling off of it
+// note this isn't utf8-y
+typedef struct
+{
+   stb_int16  match; // character/set to match
+   stb_uint16 node;  // output node to go to
+} stb_nfa_edge;
+
+typedef struct
+{
+   stb_int16 goal;   // does reaching this win the prize?
+   stb_uint8 active; // is this in the active list
+   stb_nfa_edge *out;
+   stb_uint16 *eps;  // list of epsilon closures
+} stb_nfa_node;
+
+#define STB__DFA_UNDEF  -1
+#define STB__DFA_GOAL   -2
+#define STB__DFA_END    -3
+#define STB__DFA_MGOAL  -4
+#define STB__DFA_VALID  0
+
+#define STB__NFA_STOP_GOAL -1
+
+// compiled regexp
+struct stb_matcher
+{
+   stb_uint16 start_node;
+   stb_int16 dfa_start;
+   stb_uint32 *charset;
+   int num_charset;
+   int match_start;
+   stb_nfa_node *nodes;
+   int does_lex;
+
+   // dfa matcher
+   stb_dfa    * dfa;
+   stb_uint32 * dfa_mapping;
+   stb_int16  * dfa_result;
+   int num_words_per_dfa;
+};
+
+static int stb__add_node(stb_matcher *matcher)
+{
+   stb_nfa_node z;
+   z.active = 0;
+   z.eps    = 0;
+   z.goal   = 0;
+   z.out    = 0;
+   stb_arr_push(matcher->nodes, z);
+   return stb_arr_len(matcher->nodes)-1;
+}
+
+static void stb__add_epsilon(stb_matcher *matcher, int from, int to)
+{
+   assert(from != to);
+   if (matcher->nodes[from].eps == NULL)
+      stb_arr_malloc((void **) &matcher->nodes[from].eps, matcher);
+   stb_arr_push(matcher->nodes[from].eps, to);
+}
+
+static void stb__add_edge(stb_matcher *matcher, int from, int to, int type)
+{
+   stb_nfa_edge z = { type, to };
+   if (matcher->nodes[from].out == NULL)
+      stb_arr_malloc((void **) &matcher->nodes[from].out, matcher);
+   stb_arr_push(matcher->nodes[from].out, z);
+}
+
+static char *stb__reg_parse_alt(stb_matcher *m, int s, char *r, stb_uint16 *e);
+static char *stb__reg_parse(stb_matcher *matcher, int start, char *regex, stb_uint16 *end)
+{
+   int n;
+   int last_start = -1;
+   stb_uint16 last_end = start;
+
+   while (*regex) {
+      switch (*regex) {
+         case '(':
+            last_start = last_end;
+            regex = stb__reg_parse_alt(matcher, last_end, regex+1, &last_end);
+            if (regex == NULL || *regex != ')')
+               return NULL;
+            ++regex;
+            break;
+
+         case '|':
+         case ')':
+            *end = last_end;
+            return regex;
+
+         case '?':
+            if (last_start < 0) return NULL;
+            stb__add_epsilon(matcher, last_start, last_end);
+            ++regex;
+            break;
+
+         case '*':
+            if (last_start < 0) return NULL;
+            stb__add_epsilon(matcher, last_start, last_end);
+
+            // fall through
+
+         case '+':
+            if (last_start < 0) return NULL;
+            stb__add_epsilon(matcher, last_end, last_start);
+            // prevent links back to last_end from chaining to last_start
+            n = stb__add_node(matcher);
+            stb__add_epsilon(matcher, last_end, n);
+            last_end = n;
+            ++regex;
+            break;
+
+         case '{':   // not supported!
+            // @TODO: given {n,m}, clone last_start to last_end m times,
+            // and include epsilons from start to first m-n blocks
+            return NULL; 
+
+         case '\\':
+            ++regex;
+            if (!*regex) return NULL;
+
+            // fallthrough
+         default: // match exactly this character
+            n = stb__add_node(matcher);
+            stb__add_edge(matcher, last_end, n, *regex);
+            last_start = last_end;
+            last_end = n;
+            ++regex;
+            break;
+
+         case '$':
+            n = stb__add_node(matcher);
+            stb__add_edge(matcher, last_end, n, '\n');
+            last_start = last_end;
+            last_end = n;
+            ++regex;
+            break;
+
+         case '.':
+            n = stb__add_node(matcher);
+            stb__add_edge(matcher, last_end, n, -1);
+            last_start = last_end;
+            last_end = n;
+            ++regex;
+            break;
+
+         case '[': {
+            stb_uint8 flags[256];
+            int invert = 0,z;
+            ++regex;
+            if (matcher->num_charset == 0) {
+               matcher->charset = (stb_uint *) stb_malloc(matcher, sizeof(*matcher->charset) * 256);
+               memset(matcher->charset, 0, sizeof(*matcher->charset) * 256);
+            }
+
+            memset(flags,0,sizeof(flags));
+
+            // leading ^ is special
+            if (*regex == '^')
+               ++regex, invert = 1;
+
+            // leading ] is special
+            if (*regex == ']') {
+               flags[']'] = 1;
+               ++regex;
+            }
+            while (*regex != ']') {
+               stb_uint a;
+               if (!*regex) return NULL;
+               a = *regex++;
+               if (regex[0] == '-' && regex[1] != ']') {
+                  stb_uint i,b = regex[1];
+                  regex += 2;
+                  if (b == 0) return NULL;
+                  if (a > b) return NULL;
+                  for (i=a; i <= b; ++i)
+                     flags[i] = 1;
+               } else
+                  flags[a] = 1;
+            }
+            ++regex;
+            if (invert) {
+               int i;
+               for (i=0; i < 256; ++i)
+                  flags[i] = 1-flags[i];
+            }
+
+            // now check if any existing charset matches
+            for (z=0; z < matcher->num_charset; ++z) {
+               int i, k[2] = { 0, 1 << z};
+               for (i=0; i < 256; ++i) {
+                  unsigned int f = k[flags[i]];
+                  if ((matcher->charset[i] & k[1]) != f)
+                     break;
+               }
+               if (i == 256) break;
+            }
+
+            if (z == matcher->num_charset) {
+               int i;
+               ++matcher->num_charset;
+               if (matcher->num_charset > 32) {
+                  assert(0); /* NOTREACHED */
+                  return NULL; // too many charsets, oops
+               }
+               for (i=0; i < 256; ++i)
+                  if (flags[i])
+                     matcher->charset[i] |= (1 << z);
+            }
+
+            n = stb__add_node(matcher);
+            stb__add_edge(matcher, last_end, n, -2 - z);
+            last_start = last_end;
+            last_end = n;
+            break;
+         }
+      }
+   }
+   *end = last_end;
+   return regex;
+}
+
+static char *stb__reg_parse_alt(stb_matcher *matcher, int start, char *regex, stb_uint16 *end)
+{
+   stb_uint16 last_end = start;
+   stb_uint16 main_end;
+
+   int head, tail;
+
+   head = stb__add_node(matcher);
+   stb__add_epsilon(matcher, start, head);
+
+   regex = stb__reg_parse(matcher, head, regex, &last_end);
+   if (regex == NULL) return NULL;
+   if (*regex == 0 || *regex == ')') {
+      *end = last_end;
+      return regex;
+   }
+
+   main_end = last_end;
+   tail = stb__add_node(matcher);
+
+   stb__add_epsilon(matcher, last_end, tail);
+
+   // start alternatives from the same starting node; use epsilon
+   // transitions to combine their endings
+   while(*regex && *regex != ')') {
+      assert(*regex == '|');
+      head = stb__add_node(matcher);
+      stb__add_epsilon(matcher, start, head);
+      regex = stb__reg_parse(matcher, head, regex+1, &last_end);
+      if (regex == NULL)
+         return NULL;
+      stb__add_epsilon(matcher, last_end, tail);
+   }
+
+   *end = tail;
+   return regex;
+}
+
+static char *stb__wild_parse(stb_matcher *matcher, int start, char *str, stb_uint16 *end)
+{
+   int n;
+   stb_uint16 last_end;
+
+   last_end = stb__add_node(matcher);
+   stb__add_epsilon(matcher, start, last_end);
+
+   while (*str) {
+      switch (*str) {
+            // fallthrough
+         default: // match exactly this character
+            n = stb__add_node(matcher);
+            if (toupper(*str) == tolower(*str)) {
+               stb__add_edge(matcher, last_end, n, *str);
+            } else {
+               stb__add_edge(matcher, last_end, n, tolower(*str));
+               stb__add_edge(matcher, last_end, n, toupper(*str));
+            }
+            last_end = n;
+            ++str;
+            break;
+
+         case '?':
+            n = stb__add_node(matcher);
+            stb__add_edge(matcher, last_end, n, -1);
+            last_end = n;
+            ++str;
+            break;
+
+         case '*':
+            n = stb__add_node(matcher);
+            stb__add_edge(matcher, last_end, n, -1);
+            stb__add_epsilon(matcher, last_end, n);
+            stb__add_epsilon(matcher, n, last_end);
+            last_end = n;
+            ++str;
+            break;
+      }
+   }
+
+   // now require end of string to match
+   n = stb__add_node(matcher);
+   stb__add_edge(matcher, last_end, n, 0);
+   last_end = n;
+
+   *end = last_end;
+   return str;
+}
+
+static int stb__opt(stb_matcher *m, int n)
+{
+   for(;;) {
+      stb_nfa_node *p = &m->nodes[n];
+      if (p->goal)                  return n;
+      if (stb_arr_len(p->out))      return n;
+      if (stb_arr_len(p->eps) != 1) return n;
+      n = p->eps[0];
+   }
+}
+
+static void stb__optimize(stb_matcher *m)
+{
+   // if the target of any edge is a node with exactly
+   // one out-epsilon, shorten it
+   int i,j;
+   for (i=0; i < stb_arr_len(m->nodes); ++i) {
+      stb_nfa_node *p = &m->nodes[i];
+      for (j=0; j < stb_arr_len(p->out); ++j)
+         p->out[j].node = stb__opt(m,p->out[j].node);
+      for (j=0; j < stb_arr_len(p->eps); ++j)
+         p->eps[j]      = stb__opt(m,p->eps[j]     );
+   }
+   m->start_node = stb__opt(m,m->start_node);
+}
+
+void stb_matcher_free(stb_matcher *f)
+{
+   stb_free(f);
+}
+
+static stb_matcher *stb__alloc_matcher(void)
+{
+   stb_matcher *matcher = (stb_matcher *) stb_malloc(0,sizeof(*matcher));
+
+   matcher->start_node  = 0;
+   stb_arr_malloc((void **) &matcher->nodes, matcher);
+   matcher->num_charset = 0;
+   matcher->match_start = 0;
+   matcher->does_lex    = 0;
+
+   matcher->dfa_start   = STB__DFA_UNDEF;
+   stb_arr_malloc((void **) &matcher->dfa, matcher);
+   stb_arr_malloc((void **) &matcher->dfa_mapping, matcher);
+   stb_arr_malloc((void **) &matcher->dfa_result, matcher);
+
+   stb__add_node(matcher);
+
+   return matcher;
+}
+
+static void stb__lex_reset(stb_matcher *matcher)
+{
+   // flush cached dfa data
+   stb_arr_setlen(matcher->dfa, 0);
+   stb_arr_setlen(matcher->dfa_mapping, 0);
+   stb_arr_setlen(matcher->dfa_result, 0);
+   matcher->dfa_start = STB__DFA_UNDEF;
+}
+
+stb_matcher *stb_regex_matcher(char *regex)
+{
+   void *c = stb__arr_context;
+   char *z;
+   stb_uint16 end;
+   stb_matcher *matcher = stb__alloc_matcher();
+   if (*regex == '^') {
+      matcher->match_start = 1;
+      ++regex;
+   }
+
+   z = stb__reg_parse_alt(matcher, matcher->start_node, regex, &end);
+
+   if (!z || *z) {
+      stb_free(matcher);
+      return NULL;
+   }
+
+   ((matcher->nodes)[(int) end]).goal = STB__NFA_STOP_GOAL;
+
+   return matcher;
+}
+
+stb_matcher *stb_lex_matcher(void)
+{
+   stb_matcher *matcher = stb__alloc_matcher();
+
+   matcher->match_start = 1;
+   matcher->does_lex    = 1;
+
+   return matcher;
+}
+
+int stb_lex_item(stb_matcher *matcher, char *regex, int result)
+{
+   char *z;
+   stb_uint16 end;
+
+   z = stb__reg_parse_alt(matcher, matcher->start_node, regex, &end);
+
+   if (z == NULL)
+      return 0;
+
+   stb__lex_reset(matcher);
+
+   matcher->nodes[(int) end].goal = result;
+   return 1;
+}
+
+int stb_lex_item_wild(stb_matcher *matcher, char *regex, int result)
+{
+   char *z;
+   stb_uint16 end;
+
+   z = stb__wild_parse(matcher, matcher->start_node, regex, &end);
+
+   if (z == NULL)
+      return 0;
+
+   stb__lex_reset(matcher);
+
+   matcher->nodes[(int) end].goal = result;
+   return 1;
+}
+
+static void stb__clear(stb_matcher *m, stb_uint16 *list)
+{
+   int i;
+   for (i=0; i < stb_arr_len(list); ++i)
+      m->nodes[(int) list[i]].active = 0;
+}
+
+static int stb__clear_goalcheck(stb_matcher *m, stb_uint16 *list)
+{
+   int i, t=0;
+   for (i=0; i < stb_arr_len(list); ++i) {
+      t += m->nodes[(int) list[i]].goal;
+      m->nodes[(int) list[i]].active = 0;
+   }
+   return t;
+}
+
+static stb_uint16 * stb__add_if_inactive(stb_matcher *m, stb_uint16 *list, int n)
+{
+   if (!m->nodes[n].active) {
+      stb_arr_push(list, n);
+      m->nodes[n].active = 1;
+   }
+   return list;
+}
+
+static stb_uint16 * stb__eps_closure(stb_matcher *m, stb_uint16 *list)
+{
+   int i,n = stb_arr_len(list);
+
+   for(i=0; i < n; ++i) {
+      stb_uint16 *e = m->nodes[(int) list[i]].eps;
+      if (e) {
+         int j,k = stb_arr_len(e);
+         for (j=0; j < k; ++j)
+            list = stb__add_if_inactive(m, list, e[j]);
+         n = stb_arr_len(list);
+      }
+   }
+
+   return list;
+}
+
+int stb_matcher_match(stb_matcher *m, char *str)
+{
+   int result = 0;
+   int i,j,y,z;
+   stb_uint16 *previous = NULL;
+   stb_uint16 *current = NULL;
+   stb_uint16 *temp;
+
+   stb_arr_setsize(previous, 4);
+   stb_arr_setsize(current, 4);
+
+   previous = stb__add_if_inactive(m, previous, m->start_node);
+   previous = stb__eps_closure(m,previous);
+   stb__clear(m, previous);
+
+   while (*str && stb_arr_len(previous)) {
+      y = stb_arr_len(previous);
+      for (i=0; i < y; ++i) {
+         stb_nfa_node *n = &m->nodes[(int) previous[i]];
+         z = stb_arr_len(n->out);
+         for (j=0; j < z; ++j) {
+            if (n->out[j].match >= 0) {
+               if (n->out[j].match == *str)
+                  current = stb__add_if_inactive(m, current, n->out[j].node);
+            } else if (n->out[j].match == -1) {
+               if (*str != '\n')
+                  current = stb__add_if_inactive(m, current, n->out[j].node);
+            } else if (n->out[j].match < -1) {
+               int z = -n->out[j].match - 2;
+               if (m->charset[(stb_uint8) *str] & (1 << z))
+                  current = stb__add_if_inactive(m, current, n->out[j].node);
+            }
+         }
+      }
+      stb_arr_setlen(previous, 0);
+
+      temp = previous;
+      previous = current;
+      current = temp;
+
+      previous = stb__eps_closure(m,previous);
+      stb__clear(m, previous);
+
+      ++str;
+   }
+
+   // transition to pick up a '$' at the end
+   y = stb_arr_len(previous);
+   for (i=0; i < y; ++i)
+      m->nodes[(int) previous[i]].active = 1;
+
+   for (i=0; i < y; ++i) {
+      stb_nfa_node *n = &m->nodes[(int) previous[i]];
+      z = stb_arr_len(n->out);
+      for (j=0; j < z; ++j) {
+         if (n->out[j].match == '\n')
+            current = stb__add_if_inactive(m, current, n->out[j].node);
+      }
+   }
+
+   previous = stb__eps_closure(m,previous);
+   stb__clear(m, previous);
+
+   y = stb_arr_len(previous);
+   for (i=0; i < y; ++i)
+      if (m->nodes[(int) previous[i]].goal)
+         result = 1;
+
+   stb_arr_free(previous);
+   stb_arr_free(current);
+
+   return result && *str == 0;
+}
+
+stb_int16 stb__get_dfa_node(stb_matcher *m, stb_uint16 *list)
+{
+   stb_uint16 node;
+   stb_uint32 data[8], *state, *newstate;
+   int i,j,n;
+
+   state = (stb_uint32 *) stb_temp(data, m->num_words_per_dfa * 4);
+   memset(state, 0, m->num_words_per_dfa*4);
+
+   n = stb_arr_len(list);
+   for (i=0; i < n; ++i) {
+      int x = list[i];
+      state[x >> 5] |= 1 << (x & 31);
+   }
+
+   // @TODO use a hash table
+   n = stb_arr_len(m->dfa_mapping);
+   i=j=0;
+   for(; j < n; ++i, j += m->num_words_per_dfa) {
+      // @TODO special case for <= 32
+      if (!memcmp(state, m->dfa_mapping + j, m->num_words_per_dfa*4)) {
+         node = i;
+         goto done;
+      }
+   }
+
+   assert(stb_arr_len(m->dfa) == i);
+   node = i;
+
+   newstate = stb_arr_addn(m->dfa_mapping, m->num_words_per_dfa);
+   memcpy(newstate, state, m->num_words_per_dfa*4);
+
+   // set all transitions to 'unknown'
+   stb_arr_add(m->dfa);
+   memset(m->dfa[i].transition, -1, sizeof(m->dfa[i].transition));
+
+   if (m->does_lex) {
+      int result = -1;
+      n = stb_arr_len(list);
+      for (i=0; i < n; ++i) {
+         if (m->nodes[(int) list[i]].goal > result)
+            result = m->nodes[(int) list[i]].goal;
+      }
+
+      stb_arr_push(m->dfa_result, result);
+   }
+
+done:
+   stb_tempfree(data, state);
+   return node;
+}
+
+static int stb__matcher_dfa(stb_matcher *m, char *str_c, int *len)
+{
+   stb_uint8 *str = (stb_uint8 *) str_c;
+   stb_int16 node,prevnode;
+   stb_dfa *trans;
+   int match_length = 0;
+   stb_int16 match_result=0;
+
+   if (m->dfa_start == STB__DFA_UNDEF) {
+      stb_uint16 *list;
+
+      m->num_words_per_dfa = (stb_arr_len(m->nodes)+31) >> 5;
+      stb__optimize(m);
+
+      list = stb__add_if_inactive(m, NULL, m->start_node);
+      list = stb__eps_closure(m,list);
+      if (m->does_lex) {
+         m->dfa_start = stb__get_dfa_node(m,list);
+         stb__clear(m, list);
+         // DON'T allow start state to be a goal state!
+         // this allows people to specify regexes that can match 0
+         // characters without them actually matching (also we don't
+         // check _before_ advancing anyway
+         if (m->dfa_start <= STB__DFA_MGOAL)
+            m->dfa_start = -(m->dfa_start - STB__DFA_MGOAL);
+      } else {
+         if (stb__clear_goalcheck(m, list))
+            m->dfa_start = STB__DFA_GOAL;
+         else
+            m->dfa_start = stb__get_dfa_node(m,list);
+      }
+      stb_arr_free(list);
+   }
+
+   prevnode = STB__DFA_UNDEF;
+   node = m->dfa_start;
+   trans = m->dfa;
+
+   if (m->dfa_start == STB__DFA_GOAL)
+      return 1;
+
+   for(;;) {
+      assert(node >= STB__DFA_VALID);
+
+      // fast inner DFA loop; especially if STB__DFA_VALID is 0
+
+      do {
+         prevnode = node;
+         node = trans[node].transition[*str++];
+      } while (node >= STB__DFA_VALID);
+
+      assert(node >= STB__DFA_MGOAL - stb_arr_len(m->dfa));
+      assert(node < stb_arr_len(m->dfa));
+
+      // special case for lex: need _longest_ match, so notice goal
+      // state without stopping
+      if (node <= STB__DFA_MGOAL) {
+         match_length = str - (stb_uint8 *) str_c;
+         node = -(node - STB__DFA_MGOAL);
+         match_result = node;
+         continue;
+      }
+
+      // slow NFA->DFA conversion
+
+      // or we hit the goal or the end of the string, but those
+      // can only happen once per search...
+
+      if (node == STB__DFA_UNDEF) {
+         // build a list  -- @TODO special case <= 32 states
+         // heck, use a more compact data structure for <= 16 and <= 8 ?!
+
+         // @TODO keep states/newstates around instead of reallocating them
+         stb_uint16 *states = NULL;
+         stb_uint16 *newstates = NULL;
+         int i,j,y,z;
+         stb_uint32 *flags = &m->dfa_mapping[prevnode * m->num_words_per_dfa];
+         assert(prevnode != STB__DFA_UNDEF);
+         stb_arr_setsize(states, 4);
+         stb_arr_setsize(newstates,4);
+         for (j=0; j < m->num_words_per_dfa; ++j) {
+            for (i=0; i < 32; ++i) {
+               if (*flags & (1 << i))
+                  stb_arr_push(states, j*32+i);
+            }
+            ++flags;
+         }
+         // states is now the states we were in in the previous node;
+         // so now we can compute what node it transitions to on str[-1]
+
+         y = stb_arr_len(states);
+         for (i=0; i < y; ++i) {
+            stb_nfa_node *n = &m->nodes[(int) states[i]];
+            z = stb_arr_len(n->out);
+            for (j=0; j < z; ++j) {
+               if (n->out[j].match >= 0) {
+                  if (n->out[j].match == str[-1] || (str[-1] == 0 && n->out[j].match == '\n'))
+                     newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
+               } else if (n->out[j].match == -1) {
+                  if (str[-1] != '\n' && str[-1])
+                     newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
+               } else if (n->out[j].match < -1) {
+                  int z = -n->out[j].match - 2;
+                  if (m->charset[str[-1]] & (1 << z))
+                     newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
+               }
+            }
+         }
+         // AND add in the start state!
+         if (!m->match_start || (str[-1] == '\n' && !m->does_lex))
+            newstates = stb__add_if_inactive(m, newstates, m->start_node);
+         // AND epsilon close it
+         newstates = stb__eps_closure(m, newstates);
+         // if it's a goal state, then that's all there is to it
+         if (stb__clear_goalcheck(m, newstates)) {
+            if (m->does_lex) {
+               match_length = str - (stb_uint8 *) str_c;
+               node = stb__get_dfa_node(m,newstates);
+               match_result = node;
+               node = -node + STB__DFA_MGOAL;
+               trans = m->dfa; // could have gotten realloc()ed
+            } else
+               node = STB__DFA_GOAL;
+         } else if (str[-1] == 0 || stb_arr_len(newstates) == 0) {
+            node = STB__DFA_END;
+         } else {
+            node = stb__get_dfa_node(m,newstates);
+            trans = m->dfa; // could have gotten realloc()ed
+         }
+         trans[prevnode].transition[str[-1]] = node;
+         if (node <= STB__DFA_MGOAL)
+            node = -(node - STB__DFA_MGOAL);
+         stb_arr_free(newstates);
+         stb_arr_free(states);
+      }
+
+      if (node == STB__DFA_GOAL) {
+         return 1;
+      }
+      if (node == STB__DFA_END) {
+         if (m->does_lex) {
+            if (match_result) {
+               if (len) *len = match_length;
+               return m->dfa_result[(int) match_result];
+            }
+         }
+         return 0;
+      }
+
+      assert(node != STB__DFA_UNDEF);
+   }
+}
+
+int stb_matcher_find(stb_matcher *m, char *str)
+{
+   assert(m->does_lex == 0);
+   return stb__matcher_dfa(m, str, NULL);
+}
+
+int stb_lex(stb_matcher *m, char *str, int *len)
+{
+   assert(m->does_lex);
+   return stb__matcher_dfa(m, str, len);
+}
+
+int stb_regex(char *regex, char *str)
+{
+   static stb_perfect p;
+   static stb_matcher ** matchers;
+   static char        ** regexps;
+   static char        ** regexp_cache;
+   static unsigned short *mapping;
+   int z = stb_perfect_hash(&p, (int) regex);
+   if (z >= 0) {
+      if (strcmp(regex, regexp_cache[(int) mapping[z]])) {
+         int i = mapping[z];
+         stb_matcher_free(matchers[i]);
+         free(regexp_cache[i]);
+         regexps[i] = regex;
+         regexp_cache[i] = strdup(regex);
+         matchers[i] = stb_regex_matcher(regex);
+      }
+   } else {
+      int i,n;
+      if (regex == NULL) {
+         for (i=0; i < stb_arr_len(matchers); ++i) {
+            stb_matcher_free(matchers[i]);
+            free(regexp_cache[i]);
+         }
+         stb_arr_free(matchers);
+         stb_arr_free(regexps);
+         stb_arr_free(regexp_cache);
+         stb_perfect_destroy(&p);
+         free(mapping); mapping = NULL;
+         return -1;
+      }
+      stb_arr_push(regexps, regex);
+      stb_arr_push(regexp_cache, strdup(regex));
+      stb_arr_push(matchers, stb_regex_matcher(regex));
+      stb_perfect_destroy(&p);
+      n = stb_perfect_create(&p, (unsigned int *) (char **) regexps, stb_arr_len(regexps));
+      mapping = (unsigned short *) realloc(mapping, n * sizeof(*mapping));
+      for (i=0; i < stb_arr_len(regexps); ++i)
+         mapping[stb_perfect_hash(&p, (int) regexps[i])] = i;
+      z = stb_perfect_hash(&p, (int) regex);
+   }
+   return stb_matcher_find(matchers[(int) mapping[z]], str);
+}
+
+#endif // STB_DEFINE
+
+
+#if 0
+//////////////////////////////////////////////////////////////////////////////
+//
+//                      C source-code introspection
+//
+
+// runtime structure
+typedef struct
+{
+   char *name;
+   char *type;     // base type
+   char *comment;  // content of comment field
+   int   size;     // size of base type
+   int   offset;   // field offset
+   int   arrcount[8]; // array sizes; -1 = pointer indirection; 0 = end of list
+} stb_info_field;
+
+typedef struct
+{
+   char *structname;
+   int size;
+   int num_fields;
+   stb_info_field *fields;
+} stb_info_struct;
+
+extern stb_info_struct stb_introspect_output[];
+
+// 
+
+STB_EXTERN void stb_introspect_precompiled(stb_info_struct *compiled);
+STB_EXTERN void stb__introspect(char *path, char *file);
+
+#define stb_introspect_ship()            stb__introspect(NULL, NULL, stb__introspect_output)
+
+#ifdef STB_SHIP
+#define stb_introspect()                 stb_introspect_ship()
+#define stb_introspect_path(p)           stb_introspect_ship()
+#else
+// bootstrapping: define stb_introspect() (or 'path') the first time
+#define stb_introspect()                 stb__introspect(NULL, __FILE__, NULL)
+#define stb_introspect_auto()            stb__introspect(NULL, __FILE__, stb__introspect_output)
+
+#define stb_introspect_path(p)           stb__introspect(p, __FILE__, NULL)
+#define stb_introspect_path(p)           stb__introspect(p, __FILE__, NULL)
+#endif
+
+#ifdef STB_DEFINE
+
+#ifndef STB_INTROSPECT_CPP
+   #ifdef __cplusplus
+   #define STB_INTROSPECT_CPP 1
+   #else
+   #define STB_INTROSPECT_CPP 0
+   #endif
+#endif
+
+void stb_introspect_precompiled(stb_info_struct *compiled)
+{
+
+}
+
+
+static void stb__introspect_filename(char *buffer, char *path)
+{
+   #if STB_INTROSPECT_CPP
+   sprintf(buffer, "%s/stb_introspect.cpp", path);
+   #else
+   sprintf(buffer, "%s/stb_introspect.c", path);
+   #endif
+}
+
+static void stb__introspect_compute(char *path, char *file)
+{
+   int i;
+   char ** include_list = NULL;
+   char ** introspect_list = NULL;
+   FILE *f;
+   f = fopen(file, "w");
+   if (!f) return;
+
+   fputs("// if you get compiler errors, change the following 0 to a 1:\n", f);
+   fputs("#define STB_INTROSPECT_INVALID 0\n\n", f);
+   fputs("// this will force the code to compile, and force the introspector\n", f);
+   fputs("// to run and then exit, allowing you to recompile\n\n\n", f);
+   fputs("#include \"stb.h\"\n\n",f );
+   fputs("#if STB_INTROSPECT_INVALID\n", f);
+   fputs("   stb_info_struct stb__introspect_output[] = { (void *) 1 }\n", f);
+   fputs("#else\n\n", f);
+   for (i=0; i < stb_arr_len(include_list); ++i)
+      fprintf(f, " #include \"%s\"\n", include_list[i]);
+
+   fputs(" stb_info_struct stb__introspect_output[] =\n{\n", f);
+   for (i=0; i < stb_arr_len(introspect_list); ++i)
+      fprintf(f, "  stb_introspect_%s,\n", introspect_list[i]);
+   fputs(" };\n", f);
+   fputs("#endif\n", f);
+   fclose(f);
+}
+
+static stb_info_struct *stb__introspect_info;
+
+#ifndef STB_SHIP
+
+#endif
+
+void stb__introspect(char *path, char *file, stb_info_struct *compiled)
+{
+   static int first=1;
+   if (!first) return;
+   first=0;
+
+   stb__introspect_info = compiled;
+
+   #ifndef STB_SHIP
+   if (path || file) {
+      int bail_flag = compiled && compiled[0].structname == (void *) 1;
+      int needs_building = bail_flag;
+      struct stb__stat st;
+      char buffer[1024], buffer2[1024];
+      if (!path) {
+         stb_splitpath(buffer, file, STB_PATH);
+         path = buffer;
+      }
+      // bail if the source path doesn't exist
+      if (!stb_fexists(path)) return;
+
+      stb__introspect_filename(buffer2, path);
+
+      // get source/include files timestamps, compare to output-file timestamp;
+      // if mismatched, regenerate 
+
+      if (stb__stat(buffer2, &st))
+         needs_building = STB_TRUE;
+      
+      {
+         // find any file that contains an introspection command and is newer
+         // if needs_building is already true, we don't need to do this test,
+         // but we still need these arrays, so go ahead and get them
+         char **all[3];
+         all[0] = stb_readdir_files_mask(path, "*.h");
+         all[1] = stb_readdir_files_mask(path, "*.c");
+         all[2] = stb_readdir_files_mask(path, "*.cpp");
+         int i,j;
+         if (needs_building) {
+            for (j=0; j < 3; ++j) {
+               for (i=0; i < stb_arr_len(all[j]); ++i) {
+                  struct stb__stat st2;
+                  if (!stb__stat(all[j][i], &st2)) {
+                     if (st.st_mtime < st2.st_mtime) {
+                        char *z = stb_filec(all[j][i], NULL);
+                        int found=STB_FALSE;
+                        while (y) {
+                           y = strstr(y, "//si");
+                           if (y && isspace(y[4])) {
+                              found = STB_TRUE;
+                              break;
+                           }
+                        }
+                        needs_building = STB_TRUE;
+                        goto done;
+                     }
+                  }
+               }
+            }
+           done:;
+         }
+               char *z = stb_filec(all[i], NULL), *y = z;
+               int found=STB_FALSE;
+               while (y) {
+                  y = strstr(y, "//si");
+                  if (y && isspace(y[4])) {
+                     found = STB_TRUE;
+                     break;
+                  }
+               }
+               if (found)
+                  stb_arr_push(introspect_h, strdup(all[i]));
+               free(z);
+            }
+         }
+         stb_readdir_free(all);
+         if (!needs_building) {
+            for (i=0; i < stb_arr_len(introspect_h); ++i) {
+               struct stb__stat st2;
+               if (!stb__stat(introspect_h[i], &st2))
+                  if (st.st_mtime < st2.st_mtime)
+                     needs_building = STB_TRUE;
+            }
+         }
+
+         if (needs_building) {
+            stb__introspect_compute(path, buffer2);
+         }
+      }
+   }
+   #endif
+}
+#endif
+#endif
+
+#ifdef STB_INTROSPECT
+// compile-time code-generator
+#define INTROSPECT(x)   int main(int argc, char **argv) { stb__introspect(__FILE__); return 0; }
+#define FILE(x)
+
+void stb__introspect(char *filename)
+{
+   char *file = stb_file(filename, NULL);
+   char *s = file, *t, **p;
+   char *out_name = "stb_introspect.c";
+   char *out_path;
+   STB_ARR(char) filelist = NULL;
+   int i,n;
+   if (!file) stb_fatal("Couldn't open %s", filename);
+
+   out_path = stb_splitpathdup(filename, STB_PATH);
+
+   // search for the macros
+   while (*s) {
+      char buffer[256];
+      while (*s && !isupper(*s)) ++s;
+      s = stb_strtok_invert(buffer, s, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+      s = stb_skipwhite(s);
+      if (*s == '(') {
+         ++s;
+         t = strchr(s, ')');
+         if (t == NULL) stb_fatal("Error parsing %s", filename);
+
+      }
+   }   
+}
+
+
+
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//             STB-C sliding-window dictionary compression
+//
+//  This uses a DEFLATE-style sliding window, but no bitwise entropy.
+//  Everything is on byte boundaries, so you could then apply a byte-wise
+//  entropy code, though that's nowhere near as effective.
+//
+//  An STB-C stream begins with a 16-byte header:
+//      4 bytes: 0x57 0xBC 0x00 0x00
+//      8 bytes: big-endian size of decompressed data, 64-bits
+//      4 bytes: big-endian size of window (how far back decompressor may need)
+//
+//  The following symbols appear in the stream (these were determined ad hoc,
+//  not by analysis):
+//
+//  [dict]      00000100 yyyyyyyy yyyyyyyy yyyyyyyy xxxxxxxx xxxxxxxx
+//  [END]       00000101 11111010 cccccccc cccccccc cccccccc cccccccc
+//  [dict]      00000110 yyyyyyyy yyyyyyyy yyyyyyyy xxxxxxxx
+//  [literals]  00000111 zzzzzzzz zzzzzzzz
+//  [literals]  00001zzz zzzzzzzz
+//  [dict]      00010yyy yyyyyyyy yyyyyyyy xxxxxxxx xxxxxxxx
+//  [dict]      00011yyy yyyyyyyy yyyyyyyy xxxxxxxx
+//  [literals]  001zzzzz
+//  [dict]      01yyyyyy yyyyyyyy xxxxxxxx
+//  [dict]      1xxxxxxx yyyyyyyy
+//
+//      xxxxxxxx: match length - 1
+//      yyyyyyyy: backwards distance - 1
+//      zzzzzzzz: num literals - 1
+//      cccccccc: adler32 checksum of decompressed data
+//   (all big-endian)
+
+
+STB_EXTERN stb_uint stb_decompress_length(stb_uchar *input);
+STB_EXTERN stb_uint stb_decompress(stb_uchar *out,stb_uchar *in,stb_uint len);
+STB_EXTERN stb_uint stb_compress  (stb_uchar *out,stb_uchar *in,stb_uint len);
+STB_EXTERN void stb_compress_window(int z);
+STB_EXTERN void stb_compress_hashsize(unsigned int z);
+
+STB_EXTERN int stb_compress_tofile(char *filename, char *in,  stb_uint  len);
+STB_EXTERN int stb_compress_intofile(FILE *f, char *input,    stb_uint  len);
+STB_EXTERN char *stb_decompress_fromfile(char *filename,      stb_uint *len);
+
+STB_EXTERN int stb_compress_stream_start(FILE *f);
+STB_EXTERN void stb_compress_stream_end(int close);
+STB_EXTERN void stb_write(char *data, int data_len);
+
+#ifdef STB_DEFINE
+
+stb_uint stb_decompress_length(stb_uchar *input)
+{
+   return (input[8] << 24) + (input[9] << 16) + (input[10] << 8) + input[11];
+}
+
+////////////////////           decompressor         ///////////////////////
+
+// simple implementation that just writes whole thing into big block
+
+static unsigned char *stb__barrier;
+static unsigned char *stb__barrier2;
+static unsigned char *stb__barrier3;
+static unsigned char *stb__barrier4;
+
+static stb_uchar *stb__dout;
+static void stb__match(stb_uchar *data, stb_uint length)
+{
+   // INVERSE of memmove... write each byte before copying the next...
+   assert (stb__dout + length <= stb__barrier);
+   if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
+   if (data < stb__barrier4) { stb__dout = stb__barrier+1; return; }
+   while (length--) *stb__dout++ = *data++;
+}
+
+static void stb__lit(stb_uchar *data, stb_uint length)
+{
+   assert (stb__dout + length <= stb__barrier);
+   if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
+   if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
+   memcpy(stb__dout, data, length);
+   stb__dout += length;
+}
+
+#define stb__in2(x)   ((i[x] << 8) + i[(x)+1])
+#define stb__in3(x)   ((i[x] << 16) + stb__in2((x)+1))
+#define stb__in4(x)   ((i[x] << 24) + stb__in3((x)+1))
+
+static stb_uchar *stb_decompress_token(stb_uchar *i)
+{
+   if (*i >= 0x20) { // use fewer if's for cases that expand small
+      if (*i >= 0x80)       stb__match(stb__dout-i[1]-1, i[0] - 0x80 + 1), i += 2;
+      else if (*i >= 0x40)  stb__match(stb__dout-(stb__in2(0) - 0x4000 + 1), i[2]+1), i += 3;
+      else /* *i >= 0x20 */ stb__lit(i+1, i[0] - 0x20 + 1), i += 1 + (i[0] - 0x20 + 1);
+   } else { // more ifs for cases that expand large, since overhead is amortized
+      if (*i >= 0x18)       stb__match(stb__dout-(stb__in3(0) - 0x180000 + 1), i[3]+1), i += 4;
+      else if (*i >= 0x10)  stb__match(stb__dout-(stb__in3(0) - 0x100000 + 1), stb__in2(3)+1), i += 5;
+      else if (*i >= 0x08)  stb__lit(i+2, stb__in2(0) - 0x0800 + 1), i += 2 + (stb__in2(0) - 0x0800 + 1);
+      else if (*i == 0x07)  stb__lit(i+3, stb__in2(1) + 1), i += 3 + (stb__in2(1) + 1);
+      else if (*i == 0x06)  stb__match(stb__dout-(stb__in3(1)+1), i[4]+1), i += 5;
+      else if (*i == 0x04)  stb__match(stb__dout-(stb__in3(1)+1), stb__in2(4)+1), i += 6;
+   }
+   return i;
+}
+
+stb_uint stb_decompress(stb_uchar *output, stb_uchar *i, stb_uint length)
+{
+   stb_uint olen;
+   if (stb__in4(0) != 0x57bC0000) return 0;
+   if (stb__in4(4) != 0)          return 0; // error! stream is > 4GB
+   olen = stb_decompress_length(i);
+   stb__barrier2 = i;
+   stb__barrier3 = i+length;
+   stb__barrier = output + olen;
+   stb__barrier4 = output;
+   i += 16;
+
+   stb__dout = output;
+   while (1) {
+      stb_uchar *old_i = i;
+      i = stb_decompress_token(i);
+      if (i == old_i) {
+         if (*i == 0x05 && i[1] == 0xfa) {
+            assert(stb__dout == output + olen);
+            if (stb__dout != output + olen) return 0;
+            if (stb_adler32(1, output, olen) != (stb_uint) stb__in4(2))
+               return 0;
+            return olen;
+         } else {
+            assert(0); /* NOTREACHED */
+            return 0;
+         }
+      }
+      assert(stb__dout <= output + olen); 
+      if (stb__dout > output + olen)
+         return 0;
+   }
+}
+
+char *stb_decompress_fromfile(char *filename, unsigned int *len)
+{
+   unsigned int n;
+   char *q;
+   unsigned char *p;
+   FILE *f = fopen(filename, "rb");   if (f == NULL) return NULL;
+   fseek(f, 0, SEEK_END);
+   n = ftell(f);
+   fseek(f, 0, SEEK_SET);
+   p = (unsigned char * ) malloc(n); if (p == NULL) return NULL;
+   fread(p, 1, n, f);
+   fclose(f);
+   if (p == NULL) return NULL;
+   if (p[0] != 0x57 || p[1] != 0xBc || p[2] || p[3]) { free(p); return NULL; }
+   q = (char *) malloc(stb_decompress_length(p)+1);
+   if (!q) { free(p); free(p); return NULL; }
+   *len = stb_decompress((unsigned char *) q, p, n);
+   if (*len) q[*len] = 0;
+   free(p);
+   return q;
+}
+
+#if 0
+//  streaming decompressor
+
+static struct
+{
+   stb__uchar *in_buffer;
+   stb__uchar *match;
+
+   stb__uint pending_literals;
+   stb__uint pending_match;
+} xx;
+
+
+
+static void stb__match(stb_uchar *data, stb_uint length)
+{
+   // INVERSE of memmove... write each byte before copying the next...
+   assert (stb__dout + length <= stb__barrier);
+   if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
+   if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
+   while (length--) *stb__dout++ = *data++;
+}
+
+static void stb__lit(stb_uchar *data, stb_uint length)
+{
+   assert (stb__dout + length <= stb__barrier);
+   if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
+   if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
+   memcpy(stb__dout, data, length);
+   stb__dout += length;
+}
+
+static void sx_match(stb_uchar *data, stb_uint length)
+{
+   xx.match = data;
+   xx.pending_match = length;
+}
+
+static void sx_lit(stb_uchar *data, stb_uint length)
+{
+   xx.pending_lit = length;
+}
+
+static int stb_decompress_token_state(void)
+{
+   stb__uchar *i = xx.in_buffer;
+
+   if (*i >= 0x20) { // use fewer if's for cases that expand small
+      if (*i >= 0x80)       sx_match(stb__dout-i[1]-1, i[0] - 0x80 + 1), i += 2;
+      else if (*i >= 0x40)  sx_match(stb__dout-(stb__in2(0) - 0x4000 + 1), i[2]+1), i += 3;
+      else /* *i >= 0x20 */ sx_lit(i+1, i[0] - 0x20 + 1), i += 1;
+   } else { // more ifs for cases that expand large, since overhead is amortized
+      if (*i >= 0x18)       sx_match(stb__dout-(stb__in3(0) - 0x180000 + 1), i[3]+1), i += 4;
+      else if (*i >= 0x10)  sx_match(stb__dout-(stb__in3(0) - 0x100000 + 1), stb__in2(3)+1), i += 5;
+      else if (*i >= 0x08)  sx_lit(i+2, stb__in2(0) - 0x0800 + 1), i += 2;
+      else if (*i == 0x07)  sx_lit(i+3, stb__in2(1) + 1), i += 3;
+      else if (*i == 0x06)  sx_match(stb__dout-(stb__in3(1)+1), i[4]+1), i += 5;
+      else if (*i == 0x04)  sx_match(stb__dout-(stb__in3(1)+1), stb__in2(4)+1), i += 6;
+      else return 0;
+   }
+   xx.in_buffer = i;
+   return 1;
+}
+#endif
+
+
+
+////////////////////           compressor         ///////////////////////
+
+static unsigned int stb_matchlen(stb_uchar *m1, stb_uchar *m2, stb_uint maxlen)
+{
+   stb_uint i;
+   for (i=0; i < maxlen; ++i)
+      if (m1[i] != m2[i]) return i;
+   return i;
+}
+
+// simple implementation that just takes the source data in a big block
+
+static stb_uchar *stb__out;
+static FILE      *stb__outfile;
+static stb_uint   stb__outbytes;
+
+static void stb__write(unsigned char v)
+{
+   fputc(v, stb__outfile);
+   ++stb__outbytes;
+}
+
+#define stb_out(v)    (stb__out ? *stb__out++ = (stb_uchar) (v) : stb__write((stb_uchar) (v)))
+
+static void stb_out2(stb_uint v)
+{
+   stb_out(v >> 8);
+   stb_out(v);
+}
+
+static void stb_out3(stb_uint v) { stb_out(v >> 16); stb_out(v >> 8); stb_out(v); }
+static void stb_out4(stb_uint v) { stb_out(v >> 24); stb_out(v >> 16);
+                                   stb_out(v >> 8 ); stb_out(v);                  }
+
+static void outliterals(stb_uchar *in, int numlit)
+{
+   while (numlit > 65536) {
+      outliterals(in,65536);
+      in     += 65536;
+      numlit -= 65536;
+   }
+
+   if      (numlit ==     0)    ;
+   else if (numlit <=    32)    stb_out (0x000020 + numlit-1);
+   else if (numlit <=  2048)    stb_out2(0x000800 + numlit-1);
+   else /*  numlit <= 65536) */ stb_out3(0x070000 + numlit-1);
+
+   if (stb__out) {
+      memcpy(stb__out,in,numlit);
+      stb__out += numlit;
+   } else
+      fwrite(in, 1, numlit, stb__outfile);
+}
+
+static int stb__window = 0x40000; // 256K
+void stb_compress_window(int z)
+{
+   if (z >= 0x1000000) z = 0x1000000; // limit of implementation
+   if (z <      0x100) z = 0x100;   // insanely small
+   stb__window = z;
+}
+
+static int stb_not_crap(int best, int dist)
+{
+   return   ((best > 2  &&  dist <= 0x00100)     
+          || (best > 5  &&  dist <= 0x04000)
+          || (best > 7  &&  dist <= 0x80000));
+}
+
+static  stb_uint stb__hashsize = 32768;
+void stb_compress_hashsize(unsigned int y)
+{
+   unsigned int z = 1024;
+   while (z < y) z <<= 1;
+   stb__hashsize = z >> 2;   // pass in bytes, store #pointers
+}
+
+// note that you can play with the hashing functions all you
+// want without needing to change the decompressor
+#define stb__hc(q,h,c)      (((h) << 7) + ((h) >> 25) + q[c])
+#define stb__hc2(q,h,c,d)   (((h) << 14) + ((h) >> 18) + (q[c] << 7) + q[d])
+#define stb__hc3(q,c,d,e)   ((q[c] << 14) + (q[d] << 7) + q[e])
+
+static stb_uint32 stb__running_adler;
+
+static int stb_compress_chunk(stb_uchar *history,
+                              stb_uchar *start,
+                              stb_uchar *end,
+                              int length,
+                              int *pending_literals,
+                              stb_uchar **chash,
+                              stb_uint mask)
+{
+   int window = stb__window;
+   stb_uint match_max;
+   stb_uchar *lit_start = start - *pending_literals;
+   stb_uchar *q = start;
+
+   #define STB__SCRAMBLE(h)   (((h) + ((h) >> 16)) & mask)
+
+   // stop short of the end so we don't scan off the end doing
+   // the hashing; this means we won't compress the last few bytes
+   // unless they were part of something longer
+   while (q < start+length && q+12 < end) {
+      int m;
+      stb_uint h1,h2,h3,h4, h;
+      stb_uchar *t;
+      int best = 2, dist=0;
+
+      if (q+65536 > end)
+         match_max = end-q;
+      else
+         match_max = 65536;
+
+      #define stb__nc(b,d)  ((d) <= window && ((b) > 9 || stb_not_crap(b,d)))
+
+      #define STB__TRY(t,p)  /* avoid retrying a match we already tried */ \
+                      if (p ? dist != q-t : 1)                             \
+                      if ((m = stb_matchlen(t, q, match_max)) > best)     \
+                      if (stb__nc(m,q-(t)))                                \
+                          best = m, dist = q - (t)
+
+      // rather than search for all matches, only try 4 candidate locations,
+      // chosen based on 4 different hash functions of different lengths.
+      // this strategy is inspired by LZO; hashing is unrolled here using the
+      // 'hc' macro
+      h = stb__hc3(q,0, 1, 2); h1 = STB__SCRAMBLE(h);
+                                      t = chash[h1]; if (t) STB__TRY(t,0);
+      h = stb__hc2(q,h, 3, 4); h2 = STB__SCRAMBLE(h);
+      h = stb__hc2(q,h, 5, 6);        t = chash[h2]; if (t) STB__TRY(t,1);
+      h = stb__hc2(q,h, 7, 8); h3 = STB__SCRAMBLE(h);
+      h = stb__hc2(q,h, 9,10);        t = chash[h3]; if (t) STB__TRY(t,1);
+      h = stb__hc2(q,h,11,12); h4 = STB__SCRAMBLE(h);
+                                      t = chash[h4]; if (t) STB__TRY(t,1);
+
+      // because we use a shared hash table, can only update it
+      // _after_ we've probed all of them
+      chash[h1] = chash[h2] = chash[h3] = chash[h4] = q;
+
+      if (best > 2)
+         assert(dist > 0);
+
+      // see if our best match qualifies
+      if (best < 3) { // fast path literals
+         ++q;
+      } else if (best > 2  &&  best <= 0x80    &&  dist <= 0x100) {
+         outliterals(lit_start, q-lit_start); lit_start = (q += best);
+         stb_out(0x80 + best-1);
+         stb_out(dist-1);
+      } else if (best > 5  &&  best <= 0x100   &&  dist <= 0x4000) {
+         outliterals(lit_start, q-lit_start); lit_start = (q += best);
+         stb_out2(0x4000 + dist-1);       
+         stb_out(best-1);
+      } else if (best > 7  &&  best <= 0x100   &&  dist <= 0x80000) {
+         outliterals(lit_start, q-lit_start); lit_start = (q += best);
+         stb_out3(0x180000 + dist-1);     
+         stb_out(best-1);
+      } else if (best > 8  &&  best <= 0x10000 &&  dist <= 0x80000) {
+         outliterals(lit_start, q-lit_start); lit_start = (q += best);
+         stb_out3(0x100000 + dist-1);     
+         stb_out2(best-1);
+      } else if (best > 9                      &&  dist <= 0x1000000) {
+         if (best > 65536) best = 65536;
+         outliterals(lit_start, q-lit_start); lit_start = (q += best);
+         if (best <= 0x100) {
+            stb_out(0x06);
+            stb_out3(dist-1);
+            stb_out(best-1);
+         } else {
+            stb_out(0x04);
+            stb_out3(dist-1);
+            stb_out2(best-1);
+         }
+      } else {  // fallback literals if no match was a balanced tradeoff
+         ++q;
+      }
+   }
+
+   // if we didn't get all the way, add the rest to literals
+   if (q-start < length)
+      q = start+length;
+
+   // the literals are everything from lit_start to q
+   *pending_literals = (q - lit_start);
+
+   stb__running_adler = stb_adler32(stb__running_adler, start, q - start);
+   return q - start;
+}
+
+static int stb_compress_inner(stb_uchar *input, stb_uint length)
+{
+   int literals = 0;
+   stb_uint len,i;
+
+   stb_uchar **chash;
+   chash = (stb_uchar**) malloc(stb__hashsize * sizeof(stb_uchar*));
+   if (chash == NULL) return 0; // failure
+   for (i=0; i < stb__hashsize; ++i)
+      chash[i] = NULL;
+
+   // stream signature
+   stb_out(0x57); stb_out(0xbc);
+   stb_out2(0);
+
+   stb_out4(0);       // 64-bit length requires 32-bit leading 0
+   stb_out4(length);
+   stb_out4(stb__window);
+
+   stb__running_adler = 1;
+
+   len = stb_compress_chunk(input, input, input+length, length, &literals, chash, stb__hashsize-1);
+   assert(len == length);
+
+   outliterals(input+length - literals, literals);
+
+   free(chash);
+
+   stb_out2(0x05fa); // end opcode
+
+   stb_out4(stb__running_adler);
+
+   return 1; // success
+}
+
+stb_uint stb_compress(stb_uchar *out, stb_uchar *input, stb_uint length)
+{
+   stb__out = out;
+   stb__outfile = NULL;
+
+   stb_compress_inner(input, length);
+
+   return stb__out - out;
+}
+
+int stb_compress_tofile(char *filename, char *input, unsigned int length)
+{
+   int maxlen = length + 512 + (length >> 2); // total guess
+   char *buffer = (char *) malloc(maxlen);
+   int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
+   
+   stb__out = NULL;
+   stb__outfile = fopen(filename, "wb");
+   if (!stb__outfile) return 0;
+
+   stb__outbytes = 0;
+
+   if (!stb_compress_inner((stb_uchar*)input, length))
+      return 0;
+
+   fclose(stb__outfile);
+
+   return stb__outbytes;
+}
+
+int stb_compress_intofile(FILE *f, char *input, unsigned int length)
+{
+   int maxlen = length + 512 + (length >> 2); // total guess
+   //char *buffer = (char*)malloc(maxlen);
+   //int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
+   
+   stb__out = NULL;
+   stb__outfile = f;
+   if (!stb__outfile) return 0;
+
+   stb__outbytes = 0;
+
+   if (!stb_compress_inner((stb_uchar*)input, length))
+      return 0;
+
+   return stb__outbytes;
+}
+
+//////////////////////    streaming I/O version    /////////////////////
+
+
+static stb_uint stb_out_backpatch_id(void)
+{
+   if (stb__out)
+      return (stb_uint) stb__out;
+   else
+      return ftell(stb__outfile);
+}
+
+static void stb_out_backpatch(stb_uint id, stb_uint value)
+{
+   stb_uchar data[4] = { value >> 24, value >> 16, value >> 8, value };
+   if (stb__out) {
+      memcpy((void *) id, data, 4);
+   } else {
+      stb_uint where = ftell(stb__outfile);
+      fseek(stb__outfile, id, SEEK_SET);
+      fwrite(data, 4, 1, stb__outfile);
+      fseek(stb__outfile, where, SEEK_SET);
+   }
+}
+
+// ok, the wraparound buffer was a total failure. let's instead
+// use a copying-in-place buffer, which lets us share the code.
+// This is way less efficient but it'll do for now.
+
+static struct
+{
+   stb_uchar *buffer;
+   int size;           // physical size of buffer in bytes
+
+   int valid;          // amount of valid data in bytes
+   int start;          // bytes of data already output
+
+   int window;
+   int fsize;
+
+   int pending_literals; // bytes not-quite output but counted in start
+   int length_id;
+
+   stb_uint total_bytes;
+
+   stb_uchar **chash;
+   stb_uint    hashmask;
+} xtb;
+
+static int stb_compress_streaming_start(void)
+{
+   stb_uint i;
+   xtb.size = stb__window * 3;
+   xtb.buffer = (stb_uchar*)malloc(xtb.size);
+   if (!xtb.buffer) return 0;
+
+   xtb.chash = (stb_uchar**)malloc(sizeof(*xtb.chash) * stb__hashsize);
+   if (!xtb.chash) {
+      free(xtb.buffer);
+      return 0;
+   }
+
+   for (i=0; i < stb__hashsize; ++i)
+      xtb.chash[i] = NULL;
+
+   xtb.hashmask = stb__hashsize-1;
+
+   xtb.valid        = 0;
+   xtb.start        = 0;
+   xtb.window       = stb__window;
+   xtb.fsize        = stb__window;
+   xtb.pending_literals = 0;
+   xtb.total_bytes  = 0;
+
+      // stream signature
+   stb_out(0x57); stb_out(0xbc); stb_out2(0);
+
+   stb_out4(0);       // 64-bit length requires 32-bit leading 0
+
+   xtb.length_id = stb_out_backpatch_id();
+   stb_out4(0);       // we don't know the output length yet
+
+   stb_out4(stb__window);
+
+   stb__running_adler = 1;
+
+   return 1;
+}
+
+static int stb_compress_streaming_end(void)
+{
+   // flush out any remaining data
+   stb_compress_chunk(xtb.buffer, xtb.buffer+xtb.start, xtb.buffer+xtb.valid,
+                      xtb.valid-xtb.start, &xtb.pending_literals, xtb.chash, xtb.hashmask);
+
+   // write out pending literals
+   outliterals(xtb.buffer + xtb.valid - xtb.pending_literals, xtb.pending_literals);
+
+   stb_out2(0x05fa); // end opcode
+   stb_out4(stb__running_adler);
+
+   stb_out_backpatch(xtb.length_id, xtb.total_bytes);
+
+   free(xtb.buffer);
+   free(xtb.chash);
+   return 1;
+}
+
+void stb_write(char *data, int data_len)
+{
+   stb_uint i;
+
+   // @TODO: fast path for filling the buffer and doing nothing else
+   //   if (xtb.valid + data_len < xtb.size)
+
+   xtb.total_bytes += data_len;
+
+   while (data_len) {
+      // fill buffer
+      if (xtb.valid < xtb.size) {
+         int amt = xtb.size - xtb.valid;
+         if (data_len < amt) amt = data_len;
+         memcpy(xtb.buffer + xtb.valid, data, amt);
+         data_len -= amt;
+         data     += amt;
+         xtb.valid += amt;
+      }
+      if (xtb.valid < xtb.size)
+         return;
+
+      // at this point, the buffer is full
+
+      // if we can process some data, go for it; make sure
+      // we leave an 'fsize's worth of data, though
+      if (xtb.start + xtb.fsize < xtb.valid) {
+         int amount = (xtb.valid - xtb.fsize) - xtb.start;
+         int n;
+         assert(amount > 0);
+         n = stb_compress_chunk(xtb.buffer, xtb.buffer + xtb.start, xtb.buffer + xtb.valid,
+                                amount, &xtb.pending_literals, xtb.chash, xtb.hashmask);
+         xtb.start += n;
+      }
+
+      assert(xtb.start + xtb.fsize >= xtb.valid);
+      // at this point, our future size is too small, so we
+      // need to flush some history. we, in fact, flush exactly
+      // one window's worth of history
+
+      {
+         int flush = xtb.window;
+         assert(xtb.start >= flush);
+         assert(xtb.valid >= flush);
+
+         // if 'pending literals' extends back into the shift region,
+         // write them out
+         if (xtb.start - xtb.pending_literals < flush) {
+            outliterals(xtb.buffer + xtb.start - xtb.pending_literals, xtb.pending_literals);
+            xtb.pending_literals = 0;
+         }
+
+         // now shift the window
+         memmove(xtb.buffer, xtb.buffer + flush, xtb.valid - flush);
+         xtb.start -= flush;
+         xtb.valid -= flush;
+   
+         for (i=0; i <= xtb.hashmask; ++i)
+            if (xtb.chash[i] < xtb.buffer + flush)
+               xtb.chash[i] = NULL;
+            else
+               xtb.chash[i] -= flush;
+      }
+      // and now that we've made room for more data, go back to the top
+   }
+}
+
+int stb_compress_stream_start(FILE *f)
+{
+   stb__out = NULL;
+   stb__outfile = f;
+
+   if (f == NULL)
+      return 0;
+
+   if (!stb_compress_streaming_start())
+      return 0;
+
+   return 1;
+}
+
+void stb_compress_stream_end(int close)
+{
+   stb_compress_streaming_end();
+   if (close && stb__outfile) {
+      fclose(stb__outfile);
+   }
+}
+
+#endif // STB_DEFINE
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  File abstraction... tired of not having this... we can write
+//  compressors to be layers over these that auto-close their children.
+
+
+typedef struct stbfile
+{
+   int (*getbyte)(struct stbfile *);  // -1 on EOF
+   unsigned int (*getdata)(struct stbfile *, void *block, unsigned int len);
+
+   int (*putbyte)(struct stbfile *, int byte);
+   unsigned int (*putdata)(struct stbfile *, void *block, unsigned int len);
+
+   unsigned int (*size)(struct stbfile *);
+
+   unsigned int (*tell)(struct stbfile *);
+   void (*backpatch)(struct stbfile *, unsigned int tell, void *block, unsigned int len);
+
+   void (*close)(struct stbfile *);
+
+   FILE *f;  // file to fread/fwrite
+   unsigned char *buffer; // input/output buffer
+   unsigned char *indata, *inend; // input buffer
+   union {
+      int various;
+      void *ptr;
+   };
+} stbfile;
+
+STB_EXTERN unsigned int stb_getc(stbfile *f); // read
+STB_EXTERN int stb_putc(stbfile *f, int ch); // write
+STB_EXTERN unsigned int stb_getdata(stbfile *f, void *buffer, unsigned int len); // read
+STB_EXTERN unsigned int stb_putdata(stbfile *f, void *buffer, unsigned int len); // write
+STB_EXTERN unsigned int stb_tell(stbfile *f); // read
+STB_EXTERN unsigned int stb_size(stbfile *f); // read/write
+STB_EXTERN void stb_backpatch(stbfile *f, unsigned int tell, void *buffer, unsigned int len); // write
+
+#ifdef STB_DEFINE
+
+unsigned int stb_getc(stbfile *f) { return f->getbyte(f); }
+int stb_putc(stbfile *f, int ch)  { return f->putbyte(f, ch); }
+
+unsigned int stb_getdata(stbfile *f, void *buffer, unsigned int len)
+{
+   return f->getdata(f, buffer, len);
+}
+unsigned int stb_putdata(stbfile *f, void *buffer, unsigned int len)
+{
+   return f->putdata(f, buffer, len);
+}
+void stb_close(stbfile *f)
+{
+   f->close(f);
+   free(f);
+}
+unsigned int stb_tell(stbfile *f) { return f->tell(f); }
+unsigned int stb_size(stbfile *f) { return f->size(f); }
+void stb_backpatch(stbfile *f, unsigned int tell, void *buffer, unsigned int len)
+{
+   f->backpatch(f,tell,buffer,len);
+}
+
+// FILE * implementation
+static int stb__fgetbyte(stbfile *f) { return fgetc(f->f); }
+static int stb__fputbyte(stbfile *f, int ch) { return fputc(ch, f->f)==0; }
+static unsigned int stb__fgetdata(stbfile *f, void *buffer, unsigned int len) { return fread(buffer,1,len,f->f); }
+static unsigned int stb__fputdata(stbfile *f, void *buffer, unsigned int len) { return fwrite(buffer,1,len,f->f); }
+static unsigned int stb__fsize(stbfile *f) { return stb_filelen(f->f); }
+static unsigned int stb__ftell(stbfile *f) { return ftell(f->f); }
+static void stb__fbackpatch(stbfile *f, unsigned int where, void *buffer, unsigned int len)
+{
+   fseek(f->f, where, SEEK_SET);
+   fwrite(buffer, 1, len, f->f);
+   fseek(f->f, 0, SEEK_END);
+}
+static void         stb__fclose(stbfile *f) { fclose(f->f); }
+
+stbfile *stb_openf(FILE *f)
+{
+   stbfile m = { stb__fgetbyte, stb__fgetdata,
+                 stb__fputbyte, stb__fputdata,
+                 stb__fsize, stb__ftell, stb__fbackpatch, stb__fclose,
+                 0,0,0, };
+   stbfile *z = (stbfile *) malloc(sizeof(*z));
+   if (z) {
+      *z = m;
+      z->f = f;
+   }
+   return z;
+}
+
+static int stb__nogetbyte(stbfile *f) { assert(0); return -1; }
+static unsigned int stb__nogetdata(stbfile *f, void *buffer, unsigned int len) { assert(0); return 0; }
+static int stb__noputbyte(stbfile *f, int ch) { assert(0); return 0; }
+static unsigned int stb__noputdata(stbfile *f, void *buffer, unsigned int len) { assert(0); return 0; }
+static void stb__nobackpatch(stbfile *f, unsigned int where, void *buffer, unsigned int len) { assert(0); }
+
+static int stb__bgetbyte(stbfile *s)
+{
+   if (s->indata < s->inend)
+      return *s->indata++;
+   else
+      return -1;
+}
+
+static unsigned int stb__bgetdata(stbfile *s, void *buffer, unsigned int len)
+{
+   if (s->indata + len > s->inend)
+      len = s->inend - s->indata;
+   memcpy(buffer, s->indata, len);
+   s->indata += len;
+   return len;
+}
+static unsigned int stb__bsize(stbfile *s) { return s->inend - s->buffer; }
+static unsigned int stb__btell(stbfile *s) { return s->indata - s->buffer; }
+
+static void stb__bclose(stbfile *s)
+{
+   if (s->various)
+      free(s->buffer);
+}
+
+stbfile *stb_open_inbuffer(void *buffer, unsigned int len)
+{
+   stbfile m = { stb__bgetbyte, stb__bgetdata,
+                 stb__noputbyte, stb__noputdata,
+                 stb__bsize, stb__btell, stb__nobackpatch, stb__bclose };
+   stbfile *z = (stbfile *) malloc(sizeof(*z));
+   if (z) {
+      *z = m;
+      z->buffer = (unsigned char *) buffer;
+      z->indata = z->buffer;
+      z->inend = z->indata + len;
+   }
+   return z;
+}
+
+stbfile *stb_open_inbuffer_free(void *buffer, unsigned int len)
+{
+   stbfile *z = stb_open_inbuffer(buffer, len);
+   if (z)
+      z->various = 1; // free
+   return z;
+}
+
+#ifndef STB_VERSION
+// if we've been cut-and-pasted elsewhere, you get a limited
+// version of stb_open, without the 'k' flag and utf8 support
+static void stb__fclose2(stbfile *f)
+{
+   fclose(f->f);
+}
+
+stbfile *stb_open(char *filename, char *mode)
+{
+   FILE *f = fopen(filename, mode);
+   stbfile *s;
+   if (f == NULL) return NULL;
+   s = stb_openf(f);
+   if (s)
+      s->close = stb__fclose2;
+   return s;
+}
+#else
+// the full version depends on some code in stb.h; this
+// also includes the memory buffer output format implemented with stb_arr
+static void stb__fclose2(stbfile *f)
+{
+   stb_fclose(f->f, f->various);
+}
+
+stbfile *stb_open(char *filename, char *mode)
+{
+   FILE *f = stb_fopen(filename, mode[0] == 'k' ? mode+1 : mode);
+   stbfile *s;
+   if (f == NULL) return NULL;
+   s = stb_openf(f);
+   if (s) {
+      s->close = stb__fclose2;
+      s->various = mode[0] == 'k' ? stb_keep_if_different : stb_keep_yes;
+   }
+   return s;
+}
+
+static int stb__aputbyte(stbfile *f, int ch)
+{
+   stb_arr_push(f->buffer, ch);
+   return 1;
+}
+static unsigned int stb__aputdata(stbfile *f, void *data, unsigned int len)
+{
+   memcpy(stb_arr_addn(f->buffer, (int) len), data, len);
+   return len;
+}
+static unsigned int stb__asize(stbfile *f) { return stb_arr_len(f->buffer); }
+static void stb__abackpatch(stbfile *f, unsigned int where, void *data, unsigned int len)
+{
+   memcpy(f->buffer+where, data, len);
+}
+static void stb__aclose(stbfile *f)
+{
+   *(unsigned char **) f->ptr = f->buffer;
+}
+
+stbfile *stb_open_outbuffer(unsigned char **update_on_close)
+{
+   stbfile m = { stb__nogetbyte, stb__nogetdata,
+                 stb__aputbyte, stb__aputdata,
+                 stb__asize, stb__asize, stb__abackpatch, stb__aclose };
+   stbfile *z = (stbfile *) malloc(sizeof(*z));
+   if (z) {
+      z->ptr = update_on_close;
+      *z = m;
+   }
+   return z;
+}
+#endif
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Arithmetic coder... based on cbloom's notes on the subject, should be
+//  less code than a huffman code.
+
+typedef struct
+{
+   unsigned int range_low;
+   unsigned int range_high;
+   unsigned int code, range; // decode
+   int buffered_u8;
+   int pending_ffs;
+   stbfile *output;
+} stb_arith;
+
+STB_EXTERN void stb_arith_init_encode(stb_arith *a, stbfile *out);
+STB_EXTERN void stb_arith_init_decode(stb_arith *a, stbfile *in);
+STB_EXTERN stbfile *stb_arith_encode_close(stb_arith *a);
+STB_EXTERN stbfile *stb_arith_decode_close(stb_arith *a);
+
+STB_EXTERN void stb_arith_encode(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq);
+STB_EXTERN void stb_arith_encode_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq);
+STB_EXTERN unsigned int stb_arith_decode_value(stb_arith *a, unsigned int totalfreq);
+STB_EXTERN void stb_arith_decode_advance(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq);
+STB_EXTERN unsigned int stb_arith_decode_value_log2(stb_arith *a, unsigned int totalfreq2);
+STB_EXTERN void stb_arith_decode_advance_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq);
+
+STB_EXTERN void stb_arith_encode_byte(stb_arith *a, int byte);
+STB_EXTERN int  stb_arith_decode_byte(stb_arith *a);
+
+// this is a memory-inefficient way of doing things, but it's
+// fast(?) and simple
+typedef struct
+{
+   unsigned short cumfreq;
+   unsigned short samples;
+} stb_arith_symstate_item;
+
+typedef struct
+{
+   int num_sym;
+   unsigned int pow2;
+   int countdown;
+   stb_arith_symstate_item data[1];
+} stb_arith_symstate;
+
+#ifdef STB_DEFINE
+void stb_arith_init_encode(stb_arith *a, stbfile *out)
+{
+   a->range_low = 0;
+   a->range_high = 0xffffffff;
+   a->pending_ffs = -1; // means no buffered character currently, to speed up normal case
+   a->output = out;
+}
+
+static void stb__arith_carry(stb_arith *a)
+{
+   int i;
+   assert(a->pending_ffs != -1); // can't carry with no data
+   stb_putc(a->output, a->buffered_u8);
+   for (i=0; i < a->pending_ffs; ++i)
+      stb_putc(a->output, 0);
+}
+
+static void stb__arith_putbyte(stb_arith *a, int byte)
+{
+   if (a->pending_ffs) {
+      if (a->pending_ffs == -1) { // means no buffered data; encoded for fast path efficiency
+         if (byte == 0xff)
+            stb_putc(a->output, byte); // just write it immediately
+         else {
+            a->buffered_u8 = byte;
+            a->pending_ffs = 0;
+         }
+      } else if (byte == 0xff) {
+         ++a->pending_ffs;
+      } else {
+         int i;
+         stb_putc(a->output, a->buffered_u8);
+         for (i=0; i < a->pending_ffs; ++i)
+            stb_putc(a->output, 0xff);
+      }
+   } else if (byte == 0xff) {
+      ++a->pending_ffs;
+   } else {
+      // fast path
+      stb_putc(a->output, a->buffered_u8);
+      a->buffered_u8 = byte;
+   }
+}
+
+static void stb__arith_flush(stb_arith *a)
+{
+   if (a->pending_ffs >= 0) {
+      int i;
+      stb_putc(a->output, a->buffered_u8);
+      for (i=0; i < a->pending_ffs; ++i)
+         stb_putc(a->output, 0xff);
+   }
+}
+
+static void stb__renorm_encoder(stb_arith *a)
+{
+   stb__arith_putbyte(a, a->range_low >> 24);
+   a->range_low <<= 8;
+   a->range_high = (a->range_high << 8) | 0xff;
+}
+
+static void stb__renorm_decoder(stb_arith *a)
+{
+   int c = stb_getc(a->output);
+   a->code = (a->code << 8) + (c >= 0 ? c : 0); // if EOF, insert 0
+}
+
+void stb_arith_encode(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq)
+{
+   unsigned int range = a->range_high - a->range_low;
+   unsigned int old = a->range_low;
+   range /= totalfreq;
+   a->range_low += range * cumfreq;
+   a->range_high = a->range_low + range*freq;
+   if (a->range_low < old)
+      stb__arith_carry(a);
+   while (a->range_high - a->range_low < 0x1000000)
+      stb__renorm_encoder(a);
+}
+
+void stb_arith_encode_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq)
+{
+   unsigned int range = a->range_high - a->range_low;
+   unsigned int old = a->range_low;
+   range >>= totalfreq2;
+   a->range_low += range * cumfreq;
+   a->range_high = a->range_low + range*freq;
+   if (a->range_low < old)
+      stb__arith_carry(a);
+   while (a->range_high - a->range_low < 0x1000000)
+      stb__renorm_encoder(a);
+}
+
+unsigned int stb_arith_decode_value(stb_arith *a, unsigned int totalfreq)
+{
+   unsigned int freqsize = a->range / totalfreq;
+   unsigned int z = a->code / freqsize;
+   return z >= totalfreq ? totalfreq-1 : z;
+}
+
+void stb_arith_decode_advance(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq)
+{
+   unsigned int freqsize = a->range / totalfreq; // @OPTIMIZE, share with above divide somehow?
+   a->code -= freqsize * cumfreq;
+   a->range = freqsize * freq;
+   while (a->range < 0x1000000)
+      stb__renorm_decoder(a);
+}
+
+unsigned int stb_arith_decode_value_log2(stb_arith *a, unsigned int totalfreq2)
+{
+   unsigned int freqsize = a->range >> totalfreq2;
+   unsigned int z = a->code / freqsize;
+   return z >= (1U<<totalfreq2) ? (1U<<totalfreq2)-1 : z;
+}
+
+void stb_arith_decode_advance_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq)
+{
+   unsigned int freqsize = a->range >> totalfreq2;
+   a->code -= freqsize * cumfreq;
+   a->range = freqsize * freq;
+   while (a->range < 0x1000000)
+      stb__renorm_decoder(a);
+}
+
+stbfile *stb_arith_encode_close(stb_arith *a)
+{
+   // put exactly as many bytes as we'll read, so we can turn on/off arithmetic coding in a stream
+   stb__arith_putbyte(a, a->range_low >> 24);
+   stb__arith_putbyte(a, a->range_low >> 16);
+   stb__arith_putbyte(a, a->range_low >>  8);
+   stb__arith_putbyte(a, a->range_low >>  0);
+   stb__arith_flush(a);
+   return a->output;
+}
+
+stbfile *stb_arith_decode_close(stb_arith *a)
+{
+   return a->output;
+}
+
+// this is a simple power-of-two based model -- using
+// power of two means we need one divide per decode,
+// not two.
+#define POW2_LIMIT   12
+stb_arith_symstate *stb_arith_state_create(int num_sym)
+{
+   stb_arith_symstate *s = (stb_arith_symstate *) malloc(sizeof(*s) + (num_sym-1) * sizeof(s->data[0])); 
+   if (s) {
+      int i, cf, cf_next, next;
+      int start_freq, extra;
+      s->num_sym = num_sym;
+      s->pow2 = 4;
+      while (s->pow2 < 15 && (1 << s->pow2) < 3*num_sym) {
+         ++s->pow2;
+      }
+      start_freq = (1 << s->pow2) / num_sym;
+      assert(start_freq >= 1);
+      extra = (1 << s->pow2) % num_sym;
+      // now set up the initial stats
+
+      if (s->pow2 < POW2_LIMIT)
+         next = 0;
+      else
+         next = 1;
+
+      cf = cf_next = 0;
+      for (i=0; i < extra; ++i) {
+         s->data[i].cumfreq = cf;
+         s->data[i].samples = next;
+         cf += start_freq+1;
+         cf_next += next;
+      }
+      for (; i < num_sym; ++i) {
+         s->data[i].cumfreq = cf;
+         s->data[i].samples = next;
+         cf += start_freq;
+         cf_next += next;
+      }
+      assert(cf == (1 << s->pow2));
+      // now, how long should we go until we have 2 << s->pow2 samples?
+      s->countdown = (2 << s->pow2) - cf - cf_next;
+   }
+   return s;
+}
+
+static stb_arith_state_rescale(stb_arith_symstate *s)
+{
+   if (s->pow2 < POW2_LIMIT) {
+      int pcf, cf, cf_next, next, i;
+      ++s->pow2;
+      if (s->pow2 < POW2_LIMIT)
+         next = 0;
+      else
+         next = 1;
+      cf = cf_next = 0;
+      pcf = 0;
+      for (i=0; i < s->num_sym; ++i) {
+         int sample = s->data[i].cumfreq - pcf + s->data[i].samples;
+         s->data[i].cumfreq = cf;
+         cf += sample;
+         s->data[i].samples = next;
+         cf_next += next;
+      }
+      assert(cf == (1 << s->pow2));
+      s->countdown = (2 << s->pow2) - cf - cf_next;
+   } else {
+      int pcf, cf, cf_next, i;
+      cf = cf_next = 0;
+      pcf = 0;
+      for (i=0; i < s->num_sym; ++i) {
+         int sample = (s->data[i].cumfreq - pcf + s->data[i].samples) >> 1;
+         s->data[i].cumfreq = cf;
+         cf += sample;
+         s->data[i].samples = 1;
+         cf_next += 1;
+      }
+      assert(cf == (1 << s->pow2)); // this isn't necessarily true, due to rounding down!
+      s->countdown = (2 << s->pow2) - cf - cf_next;
+   }
+}
+
+void stb_arith_encode_byte(stb_arith *a, int byte)
+{
+}
+
+int  stb_arith_decode_byte(stb_arith *a)
+{
+   return -1;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         Threads
+//
+
+#ifndef WIN32
+#ifdef STB_THREADS
+#error "threads not implemented except for Windows"
+#endif
+#endif
+
+// call this function to free any global variables for memory testing
+STB_EXTERN void stb_thread_cleanup(void);
+
+typedef void * (*stb_thread_func)(void *);
+
+// do not rely on these types, this is an implementation detail.
+// compare against STB_THREAD_NULL and ST_SEMAPHORE_NULL
+typedef void *stb_thread;
+typedef void *stb_semaphore;
+typedef void *stb_mutex;
+typedef struct stb__sync *stb_sync;
+
+#define STB_SEMAPHORE_NULL    NULL
+#define STB_THREAD_NULL       NULL
+#define STB_MUTEX_NULL        NULL
+#define STB_SYNC_NULL         NULL
+
+// get the number of processors (limited to those in the affinity mask for this process).
+STB_EXTERN int stb_processor_count(void);
+// force to run on a single core -- needed for RDTSC to work, e.g. for iprof
+STB_EXTERN void stb_force_uniprocessor(void);
+
+// stb_work functions: queue up work to be done by some worker threads
+
+// set number of threads to serve the queue; you can change this on the fly,
+// but if you decrease it, it won't decrease until things currently on the
+// queue are finished
+STB_EXTERN void          stb_work_numthreads(int n);
+// set maximum number of units in the queue; you can only set this BEFORE running any work functions
+STB_EXTERN int           stb_work_maxunits(int n);
+// enqueue some work to be done (can do this from any thread, or even from a piece of work);
+// return value of f is stored in *return_code if non-NULL
+STB_EXTERN int           stb_work(stb_thread_func f, void *d, volatile void **return_code);
+// as above, but stb_sync_reach is called on 'rel' after work is complete
+STB_EXTERN int           stb_work_reach(stb_thread_func f, void *d, volatile void **return_code, stb_sync rel);
+
+
+// necessary to call this when using volatile to order writes/reads
+STB_EXTERN void          stb_barrier(void);
+
+// support for independent queues with their own threads
+
+typedef struct stb__workqueue stb_workqueue;
+
+STB_EXTERN stb_workqueue*stb_workq_new(int numthreads, int max_units);
+STB_EXTERN stb_workqueue*stb_workq_new_flags(int numthreads, int max_units, int no_add_mutex, int no_remove_mutex);
+STB_EXTERN void          stb_workq_delete(stb_workqueue *q);
+STB_EXTERN void          stb_workq_numthreads(stb_workqueue *q, int n);
+STB_EXTERN int           stb_workq(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code);
+STB_EXTERN int           stb_workq_reach(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code, stb_sync rel);
+STB_EXTERN int           stb_workq_length(stb_workqueue *q);
+
+STB_EXTERN stb_thread    stb_create_thread (stb_thread_func f, void *d);
+STB_EXTERN stb_thread    stb_create_thread2(stb_thread_func f, void *d, volatile void **return_code, stb_semaphore rel);
+STB_EXTERN void          stb_destroy_thread(stb_thread t);
+
+STB_EXTERN stb_semaphore stb_sem_new(int max_val);
+STB_EXTERN stb_semaphore stb_sem_new_extra(int max_val, int start_val);
+STB_EXTERN void          stb_sem_delete (stb_semaphore s);
+STB_EXTERN void          stb_sem_waitfor(stb_semaphore s);
+STB_EXTERN void          stb_sem_release(stb_semaphore s);
+
+STB_EXTERN stb_mutex     stb_mutex_new(void);
+STB_EXTERN void          stb_mutex_delete(stb_mutex m);
+STB_EXTERN void          stb_mutex_begin(stb_mutex m);
+STB_EXTERN void          stb_mutex_end(stb_mutex m);
+
+STB_EXTERN stb_sync      stb_sync_new(void);
+STB_EXTERN void          stb_sync_delete(stb_sync s);
+STB_EXTERN int           stb_sync_set_target(stb_sync s, int count);
+STB_EXTERN void          stb_sync_reach_and_wait(stb_sync s);    // wait for 'target' reachers
+STB_EXTERN int           stb_sync_reach(stb_sync s);
+
+typedef struct stb__threadqueue stb_threadqueue;
+#define STB_THREADQ_DYNAMIC   0
+STB_EXTERN stb_threadqueue *stb_threadq_new(int item_size, int num_items, int many_add, int many_remove);
+STB_EXTERN void             stb_threadq_delete(stb_threadqueue *tq);
+STB_EXTERN int              stb_threadq_get(stb_threadqueue *tq, void *output);
+STB_EXTERN void             stb_threadq_get_block(stb_threadqueue *tq, void *output);
+STB_EXTERN int              stb_threadq_add(stb_threadqueue *tq, void *input);
+// can return FALSE if STB_THREADQ_DYNAMIC and attempt to grow fails
+STB_EXTERN int              stb_threadq_add_block(stb_threadqueue *tq, void *input);
+
+#ifdef STB_THREADS
+#ifdef STB_DEFINE
+
+typedef struct
+{
+   stb_thread_func f;
+   void *d;
+   volatile void **return_val;
+   stb_semaphore sem;
+} stb__thread;
+
+// this is initialized along all possible paths to create threads, therefore
+// it's always initialized before any other threads are create, therefore
+// it's free of races AS LONG AS you only create threads through stb_*
+static stb_mutex stb__threadmutex, stb__workmutex;
+
+static void stb__threadmutex_init(void)
+{
+   if (stb__threadmutex == STB_SEMAPHORE_NULL) {
+      stb__threadmutex = stb_mutex_new();
+      stb__workmutex = stb_mutex_new();
+   }
+}
+
+#ifdef STB_THREAD_TEST
+volatile float stb__t1=1, stb__t2;
+
+static void stb__wait(int n)
+{
+   float z = 0;
+   int i;
+   for (i=0; i < n; ++i)
+      z += 1 / (stb__t1+i);
+   stb__t2 = z;
+}
+#else
+#define stb__wait(x)
+#endif
+
+#ifdef _WIN32
+
+// avoid including windows.h -- note that our definitions aren't
+// exactly the same (we don't define the security descriptor struct)
+// so if you want to include windows.h, make sure you do it first.
+#include <process.h>
+
+#ifndef _WINDOWS_  // check windows.h guard
+#define STB__IMPORT   STB_EXTERN __declspec(dllimport)
+#define STB__DW       unsigned long
+
+STB__IMPORT int     __stdcall TerminateThread(void *, STB__DW);
+STB__IMPORT void *  __stdcall CreateSemaphoreA(void *sec, long,long,char*);
+STB__IMPORT int     __stdcall CloseHandle(void *);
+STB__IMPORT STB__DW __stdcall WaitForSingleObject(void *, STB__DW);
+STB__IMPORT int     __stdcall ReleaseSemaphore(void *, long, long *);
+STB__IMPORT void    __stdcall Sleep(STB__DW);
+#endif
+
+// necessary to call this when using volatile to order writes/reads
+void stb_barrier(void)
+{
+   #ifdef MemoryBarrier
+   MemoryBarrier();
+   #else
+   long temp;
+   __asm xchg temp,eax;
+   #endif
+}
+
+static void stb__thread_run(void *t)
+{
+   void *res;
+   stb__thread info = * (stb__thread *) t;
+   free(t);
+   res = info.f(info.d);
+   if (info.return_val)
+      *info.return_val = res;
+   if (info.sem != STB_SEMAPHORE_NULL)
+      stb_sem_release(info.sem);
+}
+
+static stb_thread stb_create_thread_raw(stb_thread_func f, void *d, volatile void **return_code, stb_semaphore rel)
+{
+#ifdef _MT
+#if defined(STB_FASTMALLOC) && !defined(STB_FASTMALLOC_ITS_OKAY_I_ONLY_MALLOC_IN_ONE_THREAD)
+   stb_fatal("Error! Cannot use STB_FASTMALLOC with threads.\n");
+   return STB_THREAD_NULL;
+#else
+   unsigned long id;
+   stb__thread *data = (stb__thread *) malloc(sizeof(*data));
+   if (!data) return NULL;
+   stb__threadmutex_init();
+   data->f = f;
+   data->d = d;
+   data->return_val = return_code;
+   data->sem = rel;
+   id = _beginthread(stb__thread_run, 0, data);
+   if (id == -1) return NULL;
+   return (void *) id;
+#endif
+#else
+#ifdef STB_NO_STB_STRINGS
+   stb_fatal("Invalid compilation");
+#else
+   stb_fatal("Must compile mult-threaded to use stb_thread/stb_work.");
+#endif
+   return NULL;
+#endif
+}
+
+// trivial win32 wrappers
+void          stb_destroy_thread(stb_thread t)   { TerminateThread(t,0); }
+stb_semaphore stb_sem_new(int maxv)                {return CreateSemaphoreA(NULL,0,maxv,NULL); }
+stb_semaphore stb_sem_new_extra(int maxv,int start){return CreateSemaphoreA(NULL,start,maxv,NULL); }
+void          stb_sem_delete(stb_semaphore s)    { if (s != NULL) CloseHandle(s); }
+void          stb_sem_waitfor(stb_semaphore s)   { WaitForSingleObject(s, 0xffffffff); } // INFINITE
+void          stb_sem_release(stb_semaphore s)   { ReleaseSemaphore(s,1,NULL); }
+static void   stb__thread_sleep(int ms)          { Sleep(ms); }
+
+#ifndef _WINDOWS_
+STB__IMPORT int __stdcall GetProcessAffinityMask(void *, STB__DW *, STB__DW *);
+STB__IMPORT void * __stdcall GetCurrentProcess(void);
+STB__IMPORT int __stdcall SetProcessAffinityMask(void *, STB__DW);
+#endif
+
+int stb_processor_count(void)
+{
+   unsigned long proc,sys;
+   GetProcessAffinityMask(GetCurrentProcess(), &proc, &sys);
+   return stb_bitcount(proc);
+}
+
+void stb_force_uniprocessor(void)
+{
+   unsigned long proc,sys;
+   GetProcessAffinityMask(GetCurrentProcess(), &proc, &sys);
+   if (stb_bitcount(proc) > 1) {
+      int z;
+      for (z=0; z < 32; ++z)
+         if (proc & (1 << z))
+            break;
+      if (z < 32) {
+         proc = 1 << z;
+         SetProcessAffinityMask(GetCurrentProcess(), proc);
+      }
+   }
+}
+
+#ifdef _WINDOWS_
+#define STB_MUTEX_NATIVE
+void *stb_mutex_new(void)
+{
+   CRITICAL_SECTION *p = (CRITICAL_SECTION *) malloc(sizeof(*p));
+   if (p)
+#if _WIN32_WINNT >= 0x0500
+      InitializeCriticalSectionAndSpinCount(p, 500);
+#else
+      InitializeCriticalSection(p);
+#endif
+   return p;
+}
+
+void stb_mutex_delete(void *p)
+{
+   if (p) {
+      DeleteCriticalSection((CRITICAL_SECTION *) p);
+      free(p);
+   }
+}
+
+void stb_mutex_begin(void *p)
+{
+   stb__wait(500);
+   if (p)
+      EnterCriticalSection((CRITICAL_SECTION *) p);
+}
+
+void stb_mutex_end(void *p)
+{
+   if (p)
+      LeaveCriticalSection((CRITICAL_SECTION *) p);
+   stb__wait(500);
+}
+#endif // _WINDOWS_
+
+#if 0
+// for future reference, 
+// InterlockedCompareExchange for x86:
+ int cas64_mp(void * dest, void * xcmp, void * xxchg) {
+        __asm
+        {
+                mov             esi, [xxchg]            ; exchange
+                mov             ebx, [esi + 0]
+                mov             ecx, [esi + 4]
+
+                mov             esi, [xcmp]                     ; comparand
+                mov             eax, [esi + 0]
+                mov             edx, [esi + 4]
+
+                mov             edi, [dest]                     ; destination
+                lock cmpxchg8b  [edi]
+                jz              yyyy;
+
+                mov             [esi + 0], eax;
+                mov             [esi + 4], edx;
+
+yyyy:
+                xor             eax, eax;
+                setz    al;
+        };
+
+inline unsigned __int64 _InterlockedCompareExchange64(volatile unsigned __int64 *dest
+                           ,unsigned __int64 exchange
+                           ,unsigned __int64 comperand)
+{
+    //value returned in eax::edx
+    __asm {
+        lea esi,comperand;
+        lea edi,exchange;
+
+        mov eax,[esi];
+        mov edx,4[esi];
+        mov ebx,[edi];
+        mov ecx,4[edi];
+        mov esi,dest;
+        lock CMPXCHG8B [esi];
+    } 
+#endif // #if 0
+
+#endif // _WIN32
+
+stb_thread stb_create_thread2(stb_thread_func f, void *d, volatile void **return_code, stb_semaphore rel)
+{
+   return stb_create_thread_raw(f,d,return_code,rel);
+}
+
+stb_thread stb_create_thread(stb_thread_func f, void *d)
+{
+   return stb_create_thread2(f,d,NULL,STB_SEMAPHORE_NULL);
+}
+
+// mutex implemented by wrapping semaphore
+#ifndef STB_MUTEX_NATIVE
+stb_mutex stb_mutex_new(void)            { return stb_sem_new_extra(1,1); }
+void      stb_mutex_delete(stb_mutex m)  { stb_sem_delete (m);      }
+void      stb_mutex_begin(stb_mutex m)   { stb__wait(500); if (m) stb_sem_waitfor(m); }
+void      stb_mutex_end(stb_mutex m)     { if (m) stb_sem_release(m); stb__wait(500); }
+#endif
+
+// thread merge operation
+struct stb__sync
+{
+   int target;  // target number of threads to hit it
+   int sofar;   // total threads that hit it
+   int waiting; // total threads waiting
+
+   stb_mutex start;   // mutex to prevent starting again before finishing previous
+   stb_mutex mutex;   // mutex while tweaking state
+   stb_semaphore release; // semaphore wake up waiting threads
+      // we have to wake them up one at a time, rather than using a single release
+      // call, because win32 semaphores don't let you dynamically change the max count!
+};
+
+stb_sync stb_sync_new(void)
+{
+   stb_sync s = (stb_sync) malloc(sizeof(*s));
+   if (!s) return s;
+
+   s->target = s->sofar = s->waiting = 0;
+   s->mutex   = stb_mutex_new();
+   s->start   = stb_mutex_new();
+   s->release = stb_sem_new(1);
+   if (s->mutex == STB_MUTEX_NULL || s->release == STB_SEMAPHORE_NULL || s->start == STB_MUTEX_NULL) {
+      stb_mutex_delete(s->mutex);
+      stb_mutex_delete(s->mutex);
+      stb_sem_delete(s->release);
+      free(s);
+      return NULL;
+   }
+   return s;
+}
+
+void stb_sync_delete(stb_sync s)
+{
+   if (s->waiting) {
+      // it's bad to delete while there are threads waiting!
+      // shall we wait for them to reach, or just bail? just bail
+      assert(0);
+   }
+   stb_mutex_delete(s->mutex);
+   stb_mutex_delete(s->release);
+   free(s);
+}
+
+int stb_sync_set_target(stb_sync s, int count)
+{
+   // don't allow setting a target until the last one is fully released;
+   // note that this can lead to inefficient pipelining, and maybe we'd
+   // be better off ping-ponging between two internal syncs?
+   // I tried seeing how often this happened using TryEnterCriticalSection
+   // and could _never_ get it to happen in imv(stb), even with more threads
+   // than processors. So who knows!
+   stb_mutex_begin(s->start);
+
+   // this mutex is pointless, since it's not valid for threads
+   // to call reach() before anyone calls set_target() anyway
+   stb_mutex_begin(s->mutex);
+
+   assert(s->target == 0); // enforced by start mutex
+   s->target  = count;
+   s->sofar   = 0;
+   s->waiting = 0;
+   stb_mutex_end(s->mutex);
+   return STB_TRUE;
+}
+
+void stb__sync_release(stb_sync s)
+{
+   if (s->waiting)
+      stb_sem_release(s->release);
+   else {
+      s->target = 0;
+      stb_mutex_end(s->start);
+   }
+}
+
+int stb_sync_reach(stb_sync s)
+{
+   int n;
+   stb_mutex_begin(s->mutex);
+   assert(s->sofar < s->target);
+   n = ++s->sofar; // record this value to avoid possible race if we did 'return s->sofar';
+   if (s->sofar == s->target)
+      stb__sync_release(s);
+   stb_mutex_end(s->mutex);
+   return n;
+}
+
+void stb_sync_reach_and_wait(stb_sync s)
+{
+   stb_mutex_begin(s->mutex);
+   assert(s->sofar < s->target);
+   ++s->sofar;
+   if (s->sofar == s->target) {
+      stb__sync_release(s);
+      stb_mutex_end(s->mutex);
+   } else {
+      ++s->waiting; // we're waiting, so one more waiter
+      stb_mutex_end(s->mutex); // release the mutex to other threads
+
+      stb_sem_waitfor(s->release); // wait for merge completion
+
+      stb_mutex_begin(s->mutex); // on merge completion, grab the mutex
+      --s->waiting; // we're done waiting
+      stb__sync_release(s);    // restart the next waiter
+      stb_mutex_end(s->mutex); // and now we're done
+      // this ends the same as the first case, but it's a lot
+      // clearer to understand without sharing the code
+   }
+}
+
+struct stb__threadqueue
+{
+   stb_mutex add, remove;
+   stb_semaphore nonempty, nonfull;
+   int head_blockers;  // number of threads blocking--used to know whether to release(avail)
+   int tail_blockers;
+   int head, tail, array_size, growable;
+   int item_size;
+   char *data;
+};
+
+static int stb__tq_wrap(volatile stb_threadqueue *z, int p)
+{
+   if (p == z->array_size)
+      return p - z->array_size;
+   else
+      return p;
+}
+
+int stb__threadq_get_raw(stb_threadqueue *tq2, void *output, int block)
+{
+   volatile stb_threadqueue *tq = (volatile stb_threadqueue *) tq2;
+   if (tq->head == tq->tail && !block) return 0;
+
+   stb_mutex_begin(tq->remove);
+
+   while (tq->head == tq->tail) {
+      if (!block) {
+         stb_mutex_end(tq->remove);
+         return 0;
+      }
+      ++tq->head_blockers;
+      stb_mutex_end(tq->remove);
+
+      stb_sem_waitfor(tq->nonempty);
+
+      stb_mutex_begin(tq->remove);
+      --tq->head_blockers;
+   }
+
+   memcpy(output, tq->data + tq->head*tq->item_size, tq->item_size);
+   stb_barrier();
+   tq->head = stb__tq_wrap(tq, tq->head+1);
+
+   stb_sem_release(tq->nonfull);
+   if (tq->head_blockers) // can't check if actually non-empty due to race?
+      stb_sem_release(tq->nonempty); // if there are other blockers, wake one
+
+   stb_mutex_end(tq->remove);
+   return STB_TRUE;
+}
+
+int stb__threadq_grow(volatile stb_threadqueue *tq)
+{
+   int n;
+   char *p;
+   assert(tq->remove != STB_MUTEX_NULL); // must have this to allow growth!
+   stb_mutex_begin(tq->remove);
+
+   n = tq->array_size * 2;
+   p = (char *) realloc(tq->data, n * tq->item_size);
+   if (p == NULL) {
+      stb_mutex_end(tq->remove);
+      stb_mutex_end(tq->add);
+      return STB_FALSE;
+   }
+   if (tq->tail < tq->head) {
+      memcpy(p + tq->array_size * tq->item_size, p, tq->tail * tq->item_size);
+      tq->tail += tq->array_size;
+   }
+   tq->data = p;
+   tq->array_size = n;
+
+   stb_mutex_end(tq->remove);
+   return STB_TRUE;
+}
+
+int stb__threadq_add_raw(stb_threadqueue *tq2, void *input, int block)
+{
+   int tail,pos;
+   volatile stb_threadqueue *tq = (volatile stb_threadqueue *) tq2;
+   stb_mutex_begin(tq->add);
+   for(;;) {
+      pos = tq->tail;
+      tail = stb__tq_wrap(tq, pos+1);
+      if (tail != tq->head) break;
+
+      // full
+      if (tq->growable) {
+         if (!stb__threadq_grow(tq)) {
+            stb_mutex_end(tq->add);
+            return STB_FALSE; // out of memory
+         }
+      } else if (!block) {
+         stb_mutex_end(tq->add);
+         return STB_FALSE;
+      } else {
+         ++tq->tail_blockers;
+         stb_mutex_end(tq->add);
+
+         stb_sem_waitfor(tq->nonfull);
+
+         stb_mutex_begin(tq->add);
+         --tq->tail_blockers;
+      }
+   }
+   memcpy(tq->data + tq->item_size * pos, input, tq->item_size);
+   stb_barrier();
+   tq->tail = tail;
+   stb_sem_release(tq->nonempty);
+   if (tq->tail_blockers) // can't check if actually non-full due to race?
+      stb_sem_release(tq->nonfull);
+   stb_mutex_end(tq->add);
+   return STB_TRUE;
+}
+
+int stb_threadq_length(stb_threadqueue *tq2)
+{
+   int a,b,n;
+   volatile stb_threadqueue *tq = (volatile stb_threadqueue *) tq2;
+   stb_mutex_begin(tq->add);
+   a = tq->head;
+   b = tq->tail;
+   n = tq->array_size;
+   stb_mutex_end(tq->add);
+   if (a > b) b += n;
+   return b-a;
+}
+
+int stb_threadq_get(stb_threadqueue *tq, void *output)
+{
+   return stb__threadq_get_raw(tq, output, STB_FALSE);
+}
+
+void stb_threadq_get_block(stb_threadqueue *tq, void *output)
+{
+   stb__threadq_get_raw(tq, output, STB_TRUE);
+}
+
+int stb_threadq_add(stb_threadqueue *tq, void *input)
+{
+   return stb__threadq_add_raw(tq, input, STB_FALSE);
+}
+
+int stb_threadq_add_block(stb_threadqueue *tq, void *input)
+{
+   return stb__threadq_add_raw(tq, input, STB_TRUE);
+}
+
+void stb_threadq_delete(stb_threadqueue *tq)
+{
+   if (tq) {
+      free(tq->data);
+      stb_mutex_delete(tq->add);
+      stb_mutex_delete(tq->remove);
+      stb_sem_delete(tq->nonempty);
+      stb_sem_delete(tq->nonfull);
+      free(tq);
+   }
+}
+
+#define STB_THREADQUEUE_DYNAMIC   0
+stb_threadqueue *stb_threadq_new(int item_size, int num_items, int many_add, int many_remove)
+{
+   int error=0;
+   stb_threadqueue *tq = (stb_threadqueue *) malloc(sizeof(*tq));
+   if (tq == NULL) return NULL;
+
+   if (num_items == STB_THREADQUEUE_DYNAMIC) {
+      tq->growable = STB_TRUE;
+      num_items = 32;
+   } else
+      tq->growable = STB_FALSE;
+
+   tq->item_size = item_size;
+   tq->array_size = num_items+1;
+
+   tq->add = tq->remove = STB_MUTEX_NULL;
+   tq->nonempty = tq->nonfull = STB_SEMAPHORE_NULL;
+   tq->data = NULL;
+   if (many_add)
+      { tq->add    = stb_mutex_new(); if (tq->add    == STB_MUTEX_NULL) goto error; }
+   if (many_remove || tq->growable)
+      { tq->remove = stb_mutex_new(); if (tq->remove == STB_MUTEX_NULL) goto error; }
+   tq->nonempty = stb_sem_new(1); if (tq->nonempty == STB_SEMAPHORE_NULL) goto error;
+   tq->nonfull  = stb_sem_new(1); if (tq->nonfull  == STB_SEMAPHORE_NULL) goto error;
+   tq->data = (char *) malloc(tq->item_size * tq->array_size);
+   if (tq->data == NULL) goto error;
+
+   tq->head = tq->tail = 0;
+   tq->head_blockers = tq->tail_blockers = 0;
+
+   return tq;
+
+error:
+   stb_threadq_delete(tq);
+   return NULL;
+}
+
+typedef struct
+{
+   stb_thread_func f;
+   void *d;
+   volatile void **retval;
+   stb_sync sync;
+} stb__workinfo;
+
+//static volatile stb__workinfo *stb__work;
+
+struct stb__workqueue
+{
+   int numthreads;
+   stb_threadqueue *tq;
+};
+
+static stb_workqueue *stb__work_global;
+
+static void *stb__thread_workloop(void *p)
+{
+   volatile stb_workqueue *q = (volatile stb_workqueue *) p;
+   for(;;) {
+      void *z;
+      stb__workinfo w;
+      stb_threadq_get_block(q->tq, &w);
+      if (w.f == NULL) // null work is a signal to end the thread
+         return NULL;
+      z = w.f(w.d);
+      if (w.retval) { stb_barrier(); *w.retval = z; }
+      if (w.sync != STB_SYNC_NULL) stb_sync_reach(w.sync);
+   }
+}
+
+stb_workqueue *stb_workq_new(int num_threads, int max_units)
+{
+   return stb_workq_new_flags(num_threads, max_units, 0,0);
+}
+
+stb_workqueue *stb_workq_new_flags(int numthreads, int max_units, int no_add_mutex, int no_remove_mutex)
+{
+   stb_workqueue *q = (stb_workqueue *) malloc(sizeof(*q));
+   if (q == NULL) return NULL;
+   q->tq = stb_threadq_new(sizeof(stb__workinfo), max_units, !no_add_mutex, !no_remove_mutex);
+   if (q->tq == NULL) { free(q); return NULL; }
+   q->numthreads = 0;
+   stb_workq_numthreads(q, numthreads);
+   return q;
+}
+
+void stb_workq_delete(stb_workqueue *q)
+{
+   while (stb_workq_length(q) != 0)
+      stb__thread_sleep(1);
+   stb_threadq_delete(q->tq);
+   free(q);
+}
+
+static int stb__work_maxitems = STB_THREADQUEUE_DYNAMIC;
+
+static void stb_work_init(int num_threads)
+{
+   if (stb__work_global == NULL) {
+      stb__threadmutex_init();
+      stb_mutex_begin(stb__workmutex);
+      stb_barrier();
+      if (*(stb_workqueue * volatile *) &stb__work_global == NULL)
+         stb__work_global = stb_workq_new(num_threads, stb__work_maxitems);
+      stb_mutex_end(stb__workmutex);
+   }
+}
+
+static int stb__work_raw(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code, stb_sync rel)
+{
+   stb__workinfo w;
+   if (q == NULL) {
+      stb_work_init(1);
+      q = stb__work_global;
+   }
+   w.f = f;
+   w.d = d;
+   w.retval = return_code;
+   w.sync = rel;
+   return stb_threadq_add(q->tq, &w);
+}
+
+int stb_workq_length(stb_workqueue *q)
+{
+   return stb_threadq_length(q->tq);
+}
+
+int stb_workq(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code)
+{
+   if (f == NULL) return 0;
+   return stb_workq_reach(q, f, d, return_code, NULL);
+}
+
+int stb_workq_reach(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code, stb_sync rel)
+{
+   if (f == NULL) return 0;
+   return stb__work_raw(q, f, d, return_code, rel);
+}
+
+static void stb__workq_numthreads(stb_workqueue *q, int n)
+{
+   while (q->numthreads < n) {
+      stb_create_thread(stb__thread_workloop, q);
+      ++q->numthreads;
+   }
+   while (q->numthreads > n) {
+      stb__work_raw(q, NULL, NULL, NULL, NULL);
+      --q->numthreads;
+   }
+}
+
+void stb_workq_numthreads(stb_workqueue *q, int n)
+{
+   stb_mutex_begin(stb__threadmutex);
+   stb__workq_numthreads(q,n);
+   stb_mutex_end(stb__threadmutex);
+}
+
+int stb_work_maxunits(int n)
+{
+   if (stb__work_global == NULL) {
+      stb__work_maxitems = n;
+      stb_work_init(1);
+   }
+   return stb__work_maxitems;
+}
+
+int stb_work(stb_thread_func f, void *d, volatile void **return_code)
+{
+   return stb_workq(stb__work_global, f,d,return_code);
+}
+
+int stb_work_reach(stb_thread_func f, void *d, volatile void **return_code, stb_sync rel)
+{
+   return stb_workq_reach(stb__work_global, f,d,return_code,rel);
+}
+
+void stb_work_numthreads(int n)
+{
+   if (stb__work_global == NULL)
+      stb_work_init(n);
+   else
+      stb_workq_numthreads(stb__work_global, n);
+}
+#endif // STB_DEFINE
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Background disk I/O
+//
+//
+
+#define STB_BGIO_READ_ALL   (-1)
+STB_EXTERN int stb_bgio_read    (char *filename, int offset, int len, stb_uchar **result, int *olen);
+STB_EXTERN int stb_bgio_readf   (FILE *f       , int offset, int len, stb_uchar **result, int *olen);
+STB_EXTERN int stb_bgio_read_to (char *filename, int offset, int len, stb_uchar  *buffer, int *olen);
+STB_EXTERN int stb_bgio_readf_to(FILE *f       , int offset, int len, stb_uchar  *buffer, int *olen);
+
+typedef struct
+{
+   int have_data;
+   int is_valid;
+   int is_dir;
+   time_t filetime;
+   stb_int64 filesize;
+} stb_bgstat;
+
+STB_EXTERN int stb_bgio_stat    (char *filename, stb_bgstat *result);
+
+#ifdef STB_DEFINE
+
+static stb_workqueue *stb__diskio;
+static stb_mutex stb__diskio_mutex;
+
+void stb_thread_cleanup(void)
+{
+   if (stb__work_global) stb_workq_delete(stb__work_global); stb__work_global = NULL;
+   if (stb__threadmutex) stb_mutex_delete(stb__threadmutex); stb__threadmutex = NULL;
+   if (stb__workmutex)   stb_mutex_delete(stb__workmutex);   stb__workmutex   = NULL;
+   if (stb__diskio)      stb_workq_delete(stb__diskio);      stb__diskio      = NULL;
+   if (stb__diskio_mutex)stb_mutex_delete(stb__diskio_mutex);stb__diskio_mutex= NULL;
+}
+
+
+typedef struct
+{
+   char *filename;
+   FILE *f;
+   int offset;
+   int len;
+
+   stb_bgstat *stat_out;
+   stb_uchar *output;
+   stb_uchar **result;
+   int *len_output;
+   int *flag;
+} stb__disk_command;
+
+#define STB__MAX_DISK_COMMAND 100
+static stb__disk_command stb__dc_queue[STB__MAX_DISK_COMMAND];
+static int stb__dc_offset;
+
+void stb__io_init(void)
+{
+   if (!stb__diskio) {
+      stb__threadmutex_init();
+      stb_mutex_begin(stb__threadmutex);
+      stb_barrier();
+      if (*(stb_thread * volatile *) &stb__diskio == NULL) {
+         stb__diskio_mutex = stb_mutex_new();
+         // use many threads so OS can try to schedule seeks
+         stb__diskio = stb_workq_new_flags(16,STB__MAX_DISK_COMMAND,STB_FALSE,STB_FALSE);
+      }
+      stb_mutex_end(stb__threadmutex);
+   }
+}
+
+static void * stb__io_error(stb__disk_command *dc)
+{
+   if (dc->len_output) *dc->len_output = 0;
+   if (dc->result) *dc->result = NULL;
+   if (dc->flag) *dc->flag = -1;
+   return NULL;
+}
+
+static void * stb__io_task(void *p)
+{
+   stb__disk_command *dc = (stb__disk_command *) p;
+   int len;
+   FILE *f;
+   stb_uchar *buf;
+
+   if (dc->stat_out) {  
+      struct _stati64 s;
+      if (!_stati64(dc->filename, &s)) {
+         dc->stat_out->filesize = s.st_size;
+         dc->stat_out->filetime = s.st_mtime;
+         dc->stat_out->is_dir = s.st_mode & _S_IFDIR;
+         dc->stat_out->is_valid = (s.st_mode & _S_IFREG) || dc->stat_out->is_dir;
+      } else
+         dc->stat_out->is_valid = 0;
+      stb_barrier();
+      dc->stat_out->have_data = 1;
+      free(dc->filename);
+      return 0;
+   }
+   if (dc->f) {
+      #ifdef WIN32
+      f = _fdopen(_dup(_fileno(dc->f)), "rb");
+      #else
+      f = fdopen(dup(fileno(dc->f)), "rb");
+      #endif
+      if (!f)
+         return stb__io_error(dc);
+   } else {
+      f = fopen(dc->filename, "rb");
+      free(dc->filename);
+      if (!f)
+         return stb__io_error(dc);
+   }
+
+   len = dc->len;
+   if (len < 0) {
+      fseek(f, 0, SEEK_END);
+      len = ftell(f) - dc->offset;
+   }
+
+   if (fseek(f, dc->offset, SEEK_SET)) { 
+      fclose(f);
+      return stb__io_error(dc);
+   }
+
+   if (dc->output)
+      buf = dc->output;
+   else {
+      buf = (stb_uchar *) malloc(len);
+      if (buf == NULL) {
+         fclose(f);
+         return stb__io_error(dc);
+      }
+   }
+
+   len = fread(buf, 1, len, f);
+   fclose(f);
+   if (dc->len_output) *dc->len_output = len;
+   if (dc->result) *dc->result = buf;
+   if (dc->flag) *dc->flag = 1;
+
+   return NULL;
+}
+
+int stb__io_add(char *fname, FILE *f, int off, int len, stb_uchar *out, stb_uchar **result, int *olen, int *flag, stb_bgstat *stat)
+{
+   int res;
+   stb__io_init();
+   // do memory allocation outside of mutex
+   if (fname) fname = strdup(fname);
+   stb_mutex_begin(stb__diskio_mutex);
+   {
+      stb__disk_command *dc = &stb__dc_queue[stb__dc_offset];
+      dc->filename = fname;
+      dc->f = f;
+      dc->offset = off;
+      dc->len = len;
+      dc->output = out;
+      dc->result = result;
+      dc->len_output = olen;
+      dc->flag = flag;
+      dc->stat_out = stat;
+      res = stb_workq(stb__diskio, stb__io_task, dc, NULL);
+      if (res)
+         stb__dc_offset = (stb__dc_offset + 1 == STB__MAX_DISK_COMMAND ? 0 : stb__dc_offset+1);
+   }
+   stb_mutex_end(stb__diskio_mutex);
+   return res;
+}
+
+int stb_bgio_read(char *filename, int offset, int len, stb_uchar **result, int *olen)
+{
+   return stb__io_add(filename,NULL,offset,len,NULL,result,olen,NULL,NULL);
+}
+
+int stb_bgio_readf(FILE *f, int offset, int len, stb_uchar **result, int *olen)
+{
+   return stb__io_add(NULL,f,offset,len,NULL,result,olen,NULL,NULL);
+}
+
+int stb_bgio_read_to(char *filename, int offset, int len, stb_uchar *buffer, int *olen)
+{
+   return stb__io_add(filename,NULL,offset,len,buffer,NULL,olen,NULL,NULL);
+}
+
+int stb_bgio_readf_to(FILE *f, int offset, int len, stb_uchar *buffer, int *olen)
+{
+   return stb__io_add(NULL,f,offset,len,buffer,NULL,olen,NULL,NULL);
+}
+
+STB_EXTERN int stb_bgio_stat    (char *filename, stb_bgstat *result)
+{
+   result->have_data = 0;
+   return stb__io_add(filename,NULL,0,0,0,NULL,0,NULL, result);
+}
+#endif
+#endif
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         Fast malloc implementation
+//
+//   This is a clone of TCMalloc, but without the thread support.
+//      1. large objects are allocated directly, page-aligned
+//      2. small objects are allocated in homogeonous heaps, 0 overhead
+//
+//   We keep an allocation table for pages a la TCMalloc. This would
+//   require 4MB for the entire address space, but we only allocate
+//   the parts that are in use. The overhead from using homogenous heaps
+//   everywhere is 3MB. (That is, if you allocate 1 object of each size,
+//   you'll use 3MB.)
+
+#if defined(STB_DEFINE) && (defined(_WIN32) || defined(STB_FASTMALLOC))
+
+#ifdef _WIN32
+   #ifndef _WINDOWS_
+   #ifndef STB__IMPORT
+   #define STB__IMPORT   STB_EXTERN __declspec(dllimport)
+   #define STB__DW       unsigned long
+   #endif
+   STB__IMPORT void * __stdcall VirtualAlloc(void *p, unsigned long size, unsigned long type, unsigned long protect);
+   STB__IMPORT int   __stdcall VirtualFree(void *p, unsigned long size, unsigned long freetype);
+   #endif
+   #define stb__alloc_pages_raw(x)     (stb_uint32) VirtualAlloc(NULL, (x), 0x3000, 0x04)
+   #define stb__dealloc_pages_raw(p)   VirtualFree((void *) p, 0, 0x8000)
+#else
+   #error "Platform not currently supported"
+#endif
+
+typedef struct stb__span
+{
+   int                start, len;
+   struct stb__span  *next, *prev;
+   void              *first_free;
+   unsigned short     list; // 1..256 free; 257..511 sizeclass; 0=large block
+   short              allocations; // # outstanding allocations for sizeclass
+} stb__span;  // 24
+
+static stb__span **stb__span_for_page;
+static int stb__firstpage, stb__lastpage;
+static void stb__update_page_range(int first, int last)
+{
+   stb__span **sfp;
+   int i, f,l;
+   if (first >= stb__firstpage && last <= stb__lastpage) return;
+   if (stb__span_for_page == NULL) {
+      f = first;
+      l = f+stb_max(last-f, 16384);
+      l = stb_min(l, 1<<20);
+   } else if (last > stb__lastpage) {
+      f = stb__firstpage;
+      l = f + (stb__lastpage - f) * 2;
+      l = stb_clamp(last, l,1<<20);
+   } else {
+      l = stb__lastpage;
+      f = l - (l - stb__firstpage) * 2;
+      f = stb_clamp(f, 0,first);
+   }
+   sfp = (stb__span **) stb__alloc_pages_raw(sizeof(void *) * (l-f));
+   for (i=f; i < stb__firstpage; ++i) sfp[i - f] = NULL;
+   for (   ; i < stb__lastpage ; ++i) sfp[i - f] = stb__span_for_page[i - stb__firstpage];
+   for (   ; i < l             ; ++i) sfp[i - f] = NULL;
+   if (stb__span_for_page) stb__dealloc_pages_raw(stb__span_for_page);
+   stb__firstpage = f;
+   stb__lastpage  = l;
+   stb__span_for_page = sfp;
+}
+
+static stb__span *stb__span_free=NULL;
+static stb__span *stb__span_first, *stb__span_end;
+static stb__span *stb__span_alloc(void)
+{
+   stb__span *s = stb__span_free;
+   if (s)
+      stb__span_free = s->next;
+   else {
+      if (!stb__span_first) {
+         stb__span_first = (stb__span *) stb__alloc_pages_raw(65536);
+         if (stb__span_first == NULL) return NULL;
+         stb__span_end = stb__span_first + (65536 / sizeof(stb__span));
+      }
+      s = stb__span_first++;
+      if (stb__span_first == stb__span_end) stb__span_first = NULL;
+   }
+   return s;
+}
+
+static stb__span *stb__spanlist[512];
+
+static void stb__spanlist_unlink(stb__span *s)
+{
+   if (s->prev)
+      s->prev->next = s->next;
+   else {
+      int n = s->list;
+      assert(stb__spanlist[n] == s);
+      stb__spanlist[n] = s->next;
+   }
+   if (s->next)
+      s->next->prev = s->prev;
+   s->next = s->prev = NULL;
+   s->list = 0;
+}
+
+static void stb__spanlist_add(int n, stb__span *s)
+{
+   s->list = n;
+   s->next = stb__spanlist[n];
+   s->prev = NULL;
+   stb__spanlist[n] = s;
+   if (s->next) s->next->prev = s;
+}
+
+#define stb__page_shift       12
+#define stb__page_size        (1 << stb__page_shift)
+#define stb__page_number(x)   ((x) >> stb__page_shift)
+#define stb__page_address(x)  ((x) << stb__page_shift)
+
+static void stb__set_span_for_page(stb__span *s)
+{
+   int i;
+   for (i=0; i < s->len; ++i)
+      stb__span_for_page[s->start + i - stb__firstpage] = s;
+}
+
+static stb__span *stb__coalesce(stb__span *a, stb__span *b)
+{
+   assert(a->start + a->len == b->start);
+   if (a->list) stb__spanlist_unlink(a);
+   if (b->list) stb__spanlist_unlink(b);
+   a->len += b->len;
+   b->len = 0;
+   b->next = stb__span_free;
+   stb__span_free = b;
+   stb__set_span_for_page(a);
+   return a;
+}
+
+static void stb__free_span(stb__span *s)
+{
+   stb__span *n = NULL;
+   if (s->start > stb__firstpage) {
+      n = stb__span_for_page[s->start-1 - stb__firstpage];
+      if (n && n->allocations == -2 && n->start + n->len == s->start) s = stb__coalesce(n,s);
+   }
+   if (s->start + s->len < stb__lastpage) {
+      n = stb__span_for_page[s->start + s->len - stb__firstpage];
+      if (n && n->allocations == -2 && s->start + s->len == n->start) s = stb__coalesce(s,n);
+   }
+   s->allocations = -2;
+   stb__spanlist_add(s->len > 256 ? 256 : s->len, s);
+}
+
+static stb__span *stb__alloc_pages(int num)
+{
+   stb__span *s = stb__span_alloc();
+   int p;
+   if (!s) return NULL;
+   p = stb__alloc_pages_raw(num << stb__page_shift);
+   if (p == 0) { s->next = stb__span_free; stb__span_free = s; return 0; }
+   assert(stb__page_address(stb__page_number(p)) == p);
+   p = stb__page_number(p);
+   stb__update_page_range(p, p+num);
+   s->start = p;
+   s->len   = num;
+   s->next  = NULL;
+   s->prev  = NULL;
+   stb__set_span_for_page(s);
+   return s;
+}
+
+static stb__span *stb__alloc_span(int pagecount)
+{
+   int i;
+   stb__span *p = NULL;
+   for(i=pagecount; i < 256; ++i)
+      if (stb__spanlist[i]) {
+         p = stb__spanlist[i];
+         break;
+      }
+   if (!p) {
+      p = stb__spanlist[256];
+      while (p && p->len < pagecount)
+         p = p->next;
+   }
+   if (!p) {
+      p = stb__alloc_pages(pagecount < 16 ? 16 : pagecount);
+      if (p == NULL) return 0;
+   } else
+      stb__spanlist_unlink(p);
+      
+   if (p->len > pagecount) {
+      stb__span *q = stb__span_alloc();
+      if (q) {
+         q->start = p->start + pagecount;
+         q->len   = p->len   - pagecount;
+         p->len   = pagecount;
+         for (i=0; i < q->len; ++i)
+            stb__span_for_page[q->start+i - stb__firstpage] = q;
+         stb__spanlist_add(q->len > 256 ? 256 : q->len, q);
+      }
+   }
+   return p;
+}
+
+#define STB__MAX_SMALL_SIZE     32768
+#define STB__MAX_SIZE_CLASSES   256
+
+static unsigned char stb__class_base[32];
+static unsigned char stb__class_shift[32];
+static unsigned char stb__pages_for_class[STB__MAX_SIZE_CLASSES];
+static           int stb__size_for_class[STB__MAX_SIZE_CLASSES];
+
+stb__span *stb__get_nonempty_sizeclass(int c)
+{
+   int s = c + 256, i, size, tsize; // remap to span-list index
+   char *z;
+   void *q;
+   stb__span *p = stb__spanlist[s];
+   if (p) {
+      if (p->first_free) return p; // fast path: it's in the first one in list
+      for (p=p->next; p; p=p->next)
+         if (p->first_free) {
+            // move to front for future queries
+            stb__spanlist_unlink(p);
+            stb__spanlist_add(s, p);
+            return p;
+         }
+   }
+   // no non-empty ones, so allocate a new one
+   p = stb__alloc_span(stb__pages_for_class[c]);
+   if (!p) return NULL;
+   // create the free list up front
+   size = stb__size_for_class[c];
+   tsize = stb__pages_for_class[c] << stb__page_shift;
+   i = 0;
+   z = (char *) stb__page_address(p->start);
+   q = NULL;
+   while (i + size <= tsize) {
+      * (void **) z = q; q = z;
+      z += size;
+      i += size;
+   }
+   p->first_free = q;
+   p->allocations = 0;
+   stb__spanlist_add(s,p);
+   return p;
+}
+
+static int stb__sizeclass(size_t sz)
+{
+   int z = stb_log2_floor(sz); // -1 below to group e.g. 13,14,15,16 correctly
+   return stb__class_base[z] + ((sz-1) >> stb__class_shift[z]);
+}
+
+static void stb__init_sizeclass(void)
+{
+   int i, size, overhead;
+   int align_shift = 2;  // allow 4-byte and 12-byte blocks as well, vs. TCMalloc
+   int next_class = 1;
+   int last_log = 0;
+
+   for (i = 0; i < align_shift; i++) {
+      stb__class_base [i] = next_class;
+      stb__class_shift[i] = align_shift;
+   }
+
+   for (size = 1 << align_shift; size <= STB__MAX_SMALL_SIZE; size += 1 << align_shift) {
+      i = stb_log2_floor(size);
+      if (i > last_log) {
+         if (size == 16) ++align_shift; // switch from 4-byte to 8-byte alignment
+         else if (size >= 128 && align_shift < 8) ++align_shift;
+         stb__class_base[i]  = next_class - ((size-1) >> align_shift);
+         stb__class_shift[i] = align_shift;
+         last_log = i;
+      }
+      stb__size_for_class[next_class++] = size;
+   }
+
+   for (i=1; i <= STB__MAX_SMALL_SIZE; ++i)
+      assert(i <= stb__size_for_class[stb__sizeclass(i)]);
+
+   overhead = 0;
+   for (i = 1; i < next_class; i++) {
+      int s = stb__size_for_class[i];
+      size = stb__page_size;
+      while (size % s > size >> 3)
+         size += stb__page_size;
+      stb__pages_for_class[i] = (unsigned char) (size >> stb__page_shift);
+      overhead += size;
+   }
+   assert(overhead < (4 << 20)); // make sure it's under 4MB of overhead
+}
+
+#ifdef STB_DEBUG
+#define stb__smemset(a,b,c)  memset((void *) a, b, c)
+#elif defined(STB_FASTMALLOC_INIT)
+#define stb__smemset(a,b,c)  memset((void *) a, b, c)
+#else
+#define stb__smemset(a,b,c)
+#endif
+void *stb_smalloc(size_t sz)
+{
+   stb__span *s;
+   if (sz == 0) return NULL;
+   if (stb__size_for_class[1] == 0) stb__init_sizeclass();
+   if (sz > STB__MAX_SMALL_SIZE) {
+      s = stb__alloc_span((sz + stb__page_size - 1) >> stb__page_shift);
+      if (s == NULL) return NULL;
+      s->list = 0;
+      s->next = s->prev = NULL;
+      s->allocations = -32767;
+      stb__smemset(stb__page_address(s->start), 0xcd, (sz+3)&~3);
+      return (void *) stb__page_address(s->start);
+   } else {
+      void *p;
+      int c = stb__sizeclass(sz);
+      s = stb__spanlist[256+c];
+      if (!s || !s->first_free)
+         s = stb__get_nonempty_sizeclass(c);
+      if (s == NULL) return NULL;
+      p = s->first_free;
+      s->first_free = * (void **) p;
+      ++s->allocations;
+      stb__smemset(p,0xcd, sz);
+      return p;
+   }
+}
+
+int stb_ssize(void *p)
+{
+   stb__span *s;
+   if (p == NULL) return 0;
+   s = stb__span_for_page[stb__page_number((stb_uint) p) - stb__firstpage];
+   if (s->list >= 256) {
+      return stb__size_for_class[s->list - 256];
+   } else {
+      assert(s->list == 0);
+      return s->len << stb__page_shift;
+   }
+}
+
+void stb_sfree(void *p)
+{
+   stb__span *s;
+   if (p == NULL) return;
+   s = stb__span_for_page[stb__page_number((stb_uint) p) - stb__firstpage];
+   if (s->list >= 256) {
+      stb__smemset(p, 0xfe, stb__size_for_class[s->list-256]);
+      * (void **) p = s->first_free;
+      s->first_free = p;
+      if (--s->allocations == 0) {
+         stb__spanlist_unlink(s);
+         stb__free_span(s);
+      }
+   } else {
+      assert(s->list == 0);
+      stb__smemset(p, 0xfe, stb_ssize(p));
+      stb__free_span(s);
+   }
+}
+
+void *stb_srealloc(void *p, size_t sz)
+{
+   size_t cur_size;
+   if (p == NULL) return stb_smalloc(sz);
+   if (sz == 0) { stb_sfree(p); return NULL; }
+   cur_size = stb_ssize(p);
+   if (sz > cur_size || sz <= (cur_size >> 1)) {
+      void *q;
+      if (sz > cur_size && sz < (cur_size << 1)) sz = cur_size << 1;
+      q = stb_smalloc(sz); if (q == NULL) return NULL;
+      memcpy(q, p, sz < cur_size ? sz : cur_size);
+      stb_sfree(p);
+      return q;
+   }
+   return p;
+}
+
+void *stb_scalloc(size_t n, size_t sz)
+{
+   void *p;
+   if (n == 0 || sz == 0) return NULL;
+   if (stb_log2_ceil(n) + stb_log2_ceil(n) >= 32) return NULL;
+   p = stb_smalloc(n*sz);
+   if (p) memset(p, 0, n*sz);
+   return p;
+}
+
+char *stb_sstrdup(char *s)
+{
+   int n = strlen(s);
+   char *p = (char *) stb_smalloc(n+1);
+   if (p) strcpy(p,s);
+   return p;
+}
+#endif // STB_DEFINE
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         Source code constants
+//
+// This is a trivial system to let you specify constants in source code,
+// then while running you can change the constants.
+//
+// Note that you can't wrap the #defines, because we need to know their
+// names. So we provide a pre-wrapped version without 'STB_' for convenience;
+// to request it, #define STB_CONVENIENT_H, yielding:
+//       KI -- integer
+//       KU -- unsigned integer
+//       KF -- float
+//       KD -- double
+//       KS -- string constant
+//
+// Defaults to functioning in debug build, not in release builds.
+// To force on, define STB_ALWAYS_H
+
+#ifdef STB_CONVENIENT_H
+#define KI(x) STB_I(x)
+#define KU(x) STB_UI(x)
+#define KF(x) STB_F(x)
+#define KD(x) STB_D(x)
+#define KS(x) STB_S(x)
+#endif
+
+STB_EXTERN void stb_source_path(char *str);
+#ifdef STB_DEFINE
+char *stb__source_path;
+void stb_source_path(char *path)
+{
+   stb__source_path = path;
+}
+
+char *stb__get_sourcefile_path(char *file)
+{
+   static char filebuf[512];
+   if (stb__source_path) {
+      sprintf(filebuf, "%s/%s", stb__source_path, file);
+      if (stb_fexists(filebuf)) return filebuf;
+   }
+
+   if (stb_fexists(file)) return file;
+
+   sprintf(filebuf, "../%s", file);
+   if (!stb_fexists(filebuf)) return filebuf;
+
+   return file;      
+}
+#endif
+
+#define STB_F(x)   ((float) STB_H(x))
+#define STB_UI(x)  ((unsigned int) STB_I(x))
+
+#if !defined(STB_DEBUG) && !defined(STB_ALWAYS_H)
+#define STB_D(x)   ((double) (x))
+#define STB_I(x)   ((int) (x))
+#define STB_S(x)   ((char *) (x))
+#else
+#define STB_D(x)   stb__double_constant(__FILE__, __LINE__-1, (x))
+#define STB_I(x)   stb__int_constant(__FILE__, __LINE__-1, (x))
+#define STB_S(x)   stb__string_constant(__FILE__, __LINE__-1, (x))
+
+STB_EXTERN double stb__double_constant(char *file, int line, double x);
+STB_EXTERN int    stb__int_constant(char *file, int line, int x);
+STB_EXTERN char * stb__string_constant(char *file, int line, char *str);
+
+#ifdef STB_DEFINE
+
+enum
+{
+   STB__CTYPE_int,
+   STB__CTYPE_uint,
+   STB__CTYPE_float,
+   STB__CTYPE_double,
+   STB__CTYPE_string,
+};
+
+typedef struct
+{
+   int line;
+   int type;
+   union {
+      int ival;
+      double dval;
+      char *sval;
+   };
+} stb__Entry;
+
+typedef struct
+{
+   stb__Entry *entries;
+   char *filename;
+   time_t timestamp;
+   char **file_data;
+   int file_len;
+   unsigned short *line_index;
+} stb__FileEntry;
+
+static void stb__constant_parse(stb__FileEntry *f, int i)
+{
+   char *s;
+   int n;
+   if (!stb_arr_valid(f->entries, i)) return;
+   n = f->entries[i].line;
+   if (n >= f->file_len) return;
+   s = f->file_data[n];
+   switch (f->entries[i].type) {
+      case STB__CTYPE_float:
+         while (*s) {
+            if (!strncmp(s, "STB_D(", 6)) { s+=6; goto matched_float; }
+            if (!strncmp(s, "STB_F(", 6)) { s+=6; goto matched_float; }
+            if (!strncmp(s, "KD(", 3)) { s+=3; goto matched_float; }
+            if (!strncmp(s, "KF(", 3)) { s+=3; goto matched_float; }
+            ++s;
+         }
+         break;
+      matched_float:
+         f->entries[i].dval = strtod(s, NULL);
+         break;
+      case STB__CTYPE_int:
+         while (*s) {
+            if (!strncmp(s, "STB_I(", 6)) { s+=6; goto matched_int; }
+            if (!strncmp(s, "STB_UI(", 7)) { s+=7; goto matched_int; }
+            if (!strncmp(s, "KI(", 3)) { s+=3; goto matched_int; }
+            if (!strncmp(s, "KU(", 3)) { s+=3; goto matched_int; }
+            ++s;
+         }
+         break;
+      matched_int: {
+         int neg=0;
+         s = stb_skipwhite(s);
+         while (*s == '-') { neg = !neg; s = stb_skipwhite(s+1); } // handle '- - 5', pointlessly         
+         if (s[0] == '0' && tolower(s[1]) == 'x')
+            f->entries[i].ival = strtol(s, NULL, 16);
+         else if (s[0] == '0')
+            f->entries[i].ival = strtol(s, NULL, 8);
+         else
+            f->entries[i].ival = strtol(s, NULL, 10);
+         if (neg) f->entries[i].ival = -f->entries[i].ival;
+         break;
+      }
+      case STB__CTYPE_string:
+         // @TODO
+         break;
+   }
+}
+
+static stb_sdict *stb__constant_file_hash;
+
+stb__Entry *stb__constant_get_entry(char *filename, int line, int type)
+{
+   int i;
+   stb__FileEntry *f;
+   if (stb__constant_file_hash == NULL)
+      stb__constant_file_hash = stb_sdict_new(STB_TRUE);
+   f = (stb__FileEntry*) stb_sdict_get(stb__constant_file_hash, filename);
+   if (f == NULL) {
+      char *s = stb__get_sourcefile_path(filename);
+      if (s == NULL || !stb_fexists(s)) return 0;
+      f = (stb__FileEntry *) malloc(sizeof(*f));
+      f->timestamp = stb_ftimestamp(s);
+      f->file_data = stb_stringfile(s, &f->file_len);
+      f->filename = strdup(s); // cache the full path
+      f->entries = NULL;
+      f->line_index = 0;
+      stb_arr_setlen(f->line_index, f->file_len);
+      memset(f->line_index, 0xff, stb_arr_storage(f->line_index));
+   } else {
+      time_t t = stb_ftimestamp(f->filename);
+      if (f->timestamp != t) {
+         f->timestamp = t;
+         free(f->file_data);
+         f->file_data = stb_stringfile(f->filename, &f->file_len);
+         stb_arr_setlen(f->line_index, f->file_len);
+         for (i=0; i < stb_arr_len(f->entries); ++i)
+            stb__constant_parse(f, i);
+      }
+   }
+
+   if (line >= f->file_len) return 0;
+
+   if (f->line_index[line] >= stb_arr_len(f->entries)) {
+      // need a new entry
+      int n = stb_arr_len(f->entries);
+      stb__Entry e;
+      e.line = line;
+      if (line < f->file_len)
+         f->line_index[line] = n;
+      e.type = type;
+      stb_arr_push(f->entries, e);
+      stb__constant_parse(f, n);
+   }
+   return f->entries + f->line_index[line];
+}
+
+double stb__double_constant(char *file, int line, double x)
+{
+   stb__Entry *e = stb__constant_get_entry(file, line, STB__CTYPE_float);
+   if (!e) return x;
+   return e->dval;
+}
+
+int    stb__int_constant(char *file, int line, int x)
+{
+   stb__Entry *e = stb__constant_get_entry(file, line, STB__CTYPE_int);
+   if (!e) return x;
+   return e->ival;
+}
+
+char * stb__string_constant(char *file, int line, char *x)
+{
+   stb__Entry *e = stb__constant_get_entry(file, line, STB__CTYPE_string);
+   if (!e) return x;
+   return e->sval;
+}
+
+#endif // STB_DEFINE
+#endif // !STB_DEBUG && !STB_ALWAYS_H
+
+
+#ifdef STB_STUA
+//////////////////////////////////////////////////////////////////////////
+//
+//  stua: little scripting language
+//
+//     define STB_STUA to compile it
+//
+//     see http://nothings.org/stb/stb_stua.html for documentation
+//
+//  basic parsing model:
+//
+//   lexical analysis
+//      use stb_lex() to parse tokens; keywords get their own tokens
+//
+//   parsing:
+//      recursive descent parser. too much of a hassle to make an unambiguous
+//      LR(1) grammar, and one-pass generation is clumsier (recursive descent
+//      makes it easier to e.g. compile nested functions). on the other hand,
+//      dictionary syntax required hackery to get extra lookahead.
+//
+//   codegen:
+//      output into an evaluation tree, using array indices as 'pointers'
+//
+//   run:
+//      traverse the tree; support for 'break/continue/return' is tricky
+//
+//   garbage collection:
+//      stu__mark and sweep; explicit stack with non-stu__compile_global_scope roots
+
+typedef stb_int32 stua_obj;
+
+typedef stb_idict stua_dict;
+
+STB_EXTERN void stua_run_script(char *s);
+STB_EXTERN void stua_uninit(void);
+
+extern stua_obj stua_globals;
+
+STB_EXTERN double   stua_number(stua_obj z);
+
+STB_EXTERN stua_obj stua_getnil(void);
+STB_EXTERN stua_obj stua_getfalse(void);
+STB_EXTERN stua_obj stua_gettrue(void);
+STB_EXTERN stua_obj stua_string(char *z);
+STB_EXTERN stua_obj stua_make_number(double d);
+STB_EXTERN stua_obj stua_box(int type, void *data, int size);
+
+enum
+{
+   STUA_op_negate=129,
+   STUA_op_shl,   STUA_op_ge,
+   STUA_op_shr,   STUA_op_le,
+   STUA_op_shru,
+   STUA_op_last
+};
+
+#define STUA_NO_VALUE   2     // equivalent to a tagged NULL
+STB_EXTERN stua_obj (*stua_overload)(int op, stua_obj a, stua_obj b, stua_obj c);
+
+STB_EXTERN stua_obj stua_error(char *err, ...);
+
+STB_EXTERN stua_obj stua_pushroot(stua_obj o);
+STB_EXTERN void     stua_poproot (   void   );
+
+
+#ifdef STB_DEFINE
+// INTERPRETER
+
+// 31-bit floating point implementation
+//   force the (1 << 30) bit (2nd highest bit) to be zero by re-biasing the exponent;
+//   then shift and set the bottom bit
+
+static stua_obj stu__floatp(float *f)
+{
+   unsigned int n = *(unsigned int *) f;
+   unsigned int e = n & (0xff << 23);
+
+   assert(sizeof(int) == 4 && sizeof(float) == 4);
+
+   if (!e)                    // zero?
+      n = n;                  //   no change
+   else if (e < (64 << 23))   // underflow of the packed encoding?
+      n = (n & 0x80000000);   //   signed 0
+   else if (e > (190 << 23))  // overflow of the encoding? (or INF or NAN)
+      n = (n & 0x80000000) + (127 << 23); // new INF encoding
+   else
+      n -= 0x20000000;
+
+   // now we need to shuffle the bits so that the spare bit is at the bottom
+   assert((n & 0x40000000) == 0);
+   return (n & 0x80000000) + (n << 1) + 1;
+}
+
+static unsigned char stu__getfloat_addend[256];
+static float stu__getfloat(stua_obj v)
+{
+   unsigned int n;
+   unsigned int e = ((unsigned int) v) >> 24;
+
+   n = (int) v >> 1;  // preserve high bit
+   n += stu__getfloat_addend[e] << 24;
+   return *(float *) &n;
+}
+
+stua_obj stua_float(float f) 
+{
+   return stu__floatp(&f);
+}
+
+static void stu__float_init(void)
+{
+   int i;
+   stu__getfloat_addend[0]    = 0;   // do nothing to biased exponent of 0
+   for (i=1; i < 127; ++i)
+      stu__getfloat_addend[i] = 32;  // undo the -0x20000000
+   stu__getfloat_addend[127]  = 64;  // convert packed INF to INF (0x3f -> 0x7f)
+
+   for (i=0; i < 128; ++i) // for signed floats, remove the bit we just shifted down
+      stu__getfloat_addend[128+i] = stu__getfloat_addend[i] - 64;
+}
+
+// Tagged data type implementation
+
+                                                 // TAGS:
+#define stu__int_tag          0  // of 2 bits    //   00   int
+#define stu__float_tag        1  // of 1 bit     //   01   float
+#define stu__ptr_tag          2  // of 2 bits    //   10   boxed
+                                                 //   11   float
+
+#define stu__tag(x)           ((x) & 3)
+#define stu__number(x)        (stu__tag(x) != stu__ptr_tag)
+#define stu__isint(x)         (stu__tag(x) == stu__int_tag)
+
+#define stu__int(x)           ((x) >> 2)
+#define stu__float(x)         (stu__getfloat(x))
+
+#define stu__makeint(v)       ((v)*4+stu__int_tag)
+
+// boxed data, and tag support for boxed data
+
+enum
+{
+   STU___float    = 1,   STU___int      = 2,
+   STU___number   = 3,   STU___string   = 4,
+   STU___function = 5,   STU___dict     = 6,
+   STU___boolean  = 7,   STU___error    = 8,
+};
+
+// boxed data
+#define STU__BOX  short type, stua_gc
+typedef struct stu__box { STU__BOX; } stu__box;
+
+stu__box stu__nil   = { 0, 1 };
+stu__box stu__true  = { STU___boolean, 1, };
+stu__box stu__false = { STU___boolean, 1, };
+
+#define stu__makeptr(v)  ((stua_obj)     (v) + stu__ptr_tag)
+
+#define stua_nil    stu__makeptr(&stu__nil)
+#define stua_true   stu__makeptr(&stu__true)
+#define stua_false  stu__makeptr(&stu__false)
+
+stua_obj stua_getnil(void)   { return stua_nil; }
+stua_obj stua_getfalse(void) { return stua_false; }
+stua_obj stua_gettrue(void)  { return stua_true; }
+
+#define stu__ptr(x)      ((stu__box *) ((x) - stu__ptr_tag))
+
+#define stu__checkt(t,x) ((t) == STU___float  ? ((x) & 1) == stu__float_tag : \
+                          (t) == STU___int    ? stu__isint(x)               : \
+                          (t) == STU___number ? stu__number(x)              : \
+                          stu__tag(x) == stu__ptr_tag && stu__ptr(x)->type == (t))
+
+typedef struct
+{
+   STU__BOX;
+   void *ptr;
+} stu__wrapper;
+
+// implementation of a 'function' or function + closure
+
+typedef struct stu__func
+{
+   STU__BOX;
+   stua_obj closure_source;  // 0 - regular function; 4 - C function
+                             // if closure, pointer to source function
+   union {
+      stua_obj closure_data; // partial-application data
+      void *store;           // pointer to free that holds 'code'
+      stua_obj (*func)(stua_dict *context);
+   } f;
+   // closure ends here
+   short *code;
+   int num_param;
+   stua_obj *param;  // list of parameter strings
+} stu__func;
+
+// apply this to 'short *code' to get at data
+#define stu__const(f)  ((stua_obj *) (f))
+
+static void stu__free_func(stu__func *f)
+{
+   if (f->closure_source == 0)          free(f->f.store);
+   if ((stb_uint) f->closure_source <= 4)   free(f->param);
+   free(f);
+}
+
+#define stu__pd(x)       ((stua_dict *)    stu__ptr(x))
+#define stu__pw(x)       ((stu__wrapper *) stu__ptr(x))
+#define stu__pf(x)       ((stu__func *)    stu__ptr(x))
+
+
+// garbage-collection
+
+
+static stu__box ** stu__gc_ptrlist;
+static stua_obj * stu__gc_root_stack;
+
+stua_obj stua_pushroot(stua_obj o) { stb_arr_push(stu__gc_root_stack, o); return o; }
+void     stua_poproot (   void   ) { stb_arr_pop(stu__gc_root_stack); }
+
+static stb_sdict *stu__strings;
+static void stu__mark(stua_obj z)
+{
+   int i;
+   stu__box *p = stu__ptr(z);
+   if (p->stua_gc == 1) return; // already marked
+   assert(p->stua_gc == 0);
+   p->stua_gc = 1;
+   switch(p->type) {
+      case STU___function: {
+         stu__func *f = (stu__func *) p;
+         if ((stb_uint) f->closure_source <= 4) {
+            if (f->closure_source == 0) {
+               for (i=1; i <= f->code[0]; ++i)
+                  if (!stu__number(((stua_obj *) f->code)[-i]))
+                     stu__mark(((stua_obj *) f->code)[-i]);
+            }
+            for (i=0; i < f->num_param; ++i)
+               stu__mark(f->param[i]);
+         } else {
+            stu__mark(f->closure_source);
+            stu__mark(f->f.closure_data);
+         }
+         break;
+      }
+      case STU___dict: {
+         stua_dict *e = (stua_dict *) p;
+         for (i=0; i < e->limit; ++i)
+            if (e->table[i].k != STB_IEMPTY && e->table[i].k != STB_IDEL) {
+               if (!stu__number(e->table[i].k)) stu__mark((int) e->table[i].k);
+               if (!stu__number(e->table[i].v)) stu__mark((int) e->table[i].v);
+            }
+         break;
+      }
+   }
+}
+
+static int stu__num_allocs, stu__size_allocs;
+static stua_obj stu__flow_val = stua_nil; // used for break & return
+
+static void stua_gc(int force)
+{
+   int i;
+   if (!force && stu__num_allocs == 0 && stu__size_allocs == 0) return;
+   stu__num_allocs = stu__size_allocs = 0;
+   //printf("[gc]\n");
+
+   // clear marks
+   for (i=0; i < stb_arr_len(stu__gc_ptrlist); ++i)
+       stu__gc_ptrlist[i]->stua_gc = 0;
+
+   // stu__mark everything reachable
+   stu__nil.stua_gc = stu__true.stua_gc = stu__false.stua_gc = 1;
+   stu__mark(stua_globals);
+   if (!stu__number(stu__flow_val)) 
+      stu__mark(stu__flow_val);
+   for (i=0; i < stb_arr_len(stu__gc_root_stack); ++i)
+      if (!stu__number(stu__gc_root_stack[i]))
+         stu__mark(stu__gc_root_stack[i]);
+
+   // sweep unreachables
+   for (i=0; i < stb_arr_len(stu__gc_ptrlist);) {
+      stu__box *z = stu__gc_ptrlist[i];         
+      if (!z->stua_gc) {
+         switch (z->type) {
+            case STU___dict:        stb_idict_destroy((stua_dict *) z); break;
+            case STU___error:       free(((stu__wrapper *) z)->ptr); break;
+            case STU___string:      stb_sdict_remove(stu__strings, (char*) ((stu__wrapper *) z)->ptr, NULL); free(z); break;
+            case STU___function:    stu__free_func((stu__func *) z); break;
+         }
+         // swap in the last item over this, and repeat
+         z = stb_arr_pop(stu__gc_ptrlist);
+         stu__gc_ptrlist[i] = z;         
+      } else
+         ++i;
+   }
+}
+
+static void stu__consider_gc(stua_obj x)
+{
+   if (stu__size_allocs < 100000) return;
+   if (stu__num_allocs < 10 && stu__size_allocs < 1000000) return;
+   stb_arr_push(stu__gc_root_stack, x);
+   stua_gc(0);
+   stb_arr_pop(stu__gc_root_stack);
+}
+
+static stua_obj stu__makeobj(int type, void *data, int size, int safe_to_gc)
+{
+   stua_obj x = stu__makeptr(data);
+   ((stu__box *) data)->type = type;
+   stb_arr_push(stu__gc_ptrlist, (stu__box *) data);
+   stu__num_allocs  += 1;
+   stu__size_allocs += size;
+   if (safe_to_gc) stu__consider_gc(x);
+   return x;
+}
+
+stua_obj stua_box(int type, void *data, int size)
+{
+   stu__wrapper *p = (stu__wrapper *) malloc(sizeof(*p));
+   p->ptr = data;
+   return stu__makeobj(type, p, size, 0);
+}
+
+// a stu string can be directly compared for equality, because
+// they go into a hash table
+stua_obj stua_string(char *z)
+{
+   stu__wrapper *b = (stu__wrapper *) stb_sdict_get(stu__strings, z);
+   if (b == NULL) {
+      int o = stua_box(STU___string, NULL, strlen(z) + sizeof(*b));
+      b = stu__pw(o);
+      stb_sdict_add(stu__strings, z, b);
+      stb_sdict_getkey(stu__strings, z, (char **) &b->ptr);
+   }
+   return stu__makeptr(b);
+}
+
+// stb_obj dictionary is just an stb_idict
+static void     stu__set(stua_dict *d, stua_obj k, stua_obj v)
+{ if (stb_idict_set(d, k, v)) stu__size_allocs += 8; }
+
+static stua_obj stu__get(stua_dict *d, stua_obj k, stua_obj res)
+{
+   stb_idict_get_flag(d, k, &res);
+   return res;
+}
+
+static stua_obj make_string(char *z, int len)
+{
+   stua_obj s;
+   char temp[256], *q = (char *) stb_temp(temp, len+1), *p = q;
+   while (len > 0) {
+      if (*z == '\\') {
+              if (z[1] == 'n') *p = '\n';
+         else if (z[1] == 'r') *p = '\r';
+         else if (z[1] == 't') *p = '\t';
+         else                  *p = z[1];
+         p += 1; z += 2; len -= 2;
+      } else {
+         *p++ = *z++; len -= 1;
+      }
+   }
+   *p = 0;
+   s = stua_string(q);
+   stb_tempfree(temp, q);
+   return s;
+}
+
+enum token_names
+{
+   T__none=128,
+   ST_shl = STUA_op_shl,    ST_ge  = STUA_op_ge,
+   ST_shr = STUA_op_shr,    ST_le = STUA_op_le,
+   ST_shru = STUA_op_shru,  STU__negate = STUA_op_negate,
+   ST__reset_numbering = STUA_op_last,
+   ST_white,
+   ST_id, ST_float, ST_decimal, ST_hex, ST_char,ST_string, ST_number,
+   // make sure the keywords come _AFTER_ ST_id, so stb_lex prefer them
+   ST_if,      ST_while,    ST_for,     ST_eq,  ST_nil,
+   ST_then,    ST_do,       ST_in,      ST_ne,  ST_true,
+   ST_else,    ST_break,    ST_let,     ST_and, ST_false,
+   ST_elseif,  ST_continue, ST_into,    ST_or,  ST_repeat,
+   ST_end,     ST_as,       ST_return,  ST_var, ST_func,
+   ST_catch,   ST__frame,
+   ST__max_terminals,
+
+   STU__defaultparm, STU__seq,
+};
+
+static stua_dict  * stu__globaldict;
+       stua_obj     stua_globals;
+
+static enum
+{
+   FLOW_normal,  FLOW_continue,   FLOW_break,  FLOW_return,  FLOW_error,
+} stu__flow;
+
+stua_obj stua_error(char *z, ...)
+{
+   stua_obj a;
+   char temp[4096], *x;
+   va_list v; va_start(v,z); vsprintf(temp, z, v); va_end(v);
+   x = strdup(temp);
+   a = stua_box(STU___error, x, strlen(x));
+   stu__flow = FLOW_error;
+   stu__flow_val = a;
+   return stua_nil;
+}
+
+double stua_number(stua_obj z)
+{
+   return stu__tag(z) == stu__int_tag ? stu__int(z) : stu__float(z);
+}
+
+stua_obj stua_make_number(double d)
+{
+   double e = floor(d);
+   if (e == d && e < (1 << 29) && e >= -(1 << 29))
+      return stu__makeint((int) e);
+   else
+      return stua_float((float) d);
+}
+
+stua_obj (*stua_overload)(int op, stua_obj a, stua_obj b, stua_obj c) = NULL;
+
+static stua_obj stu__op(int op, stua_obj a, stua_obj b, stua_obj c)
+{
+   stua_obj r = STUA_NO_VALUE;
+   if (op == '+') {
+      if (stu__checkt(STU___string, a) && stu__checkt(STU___string, b)) {
+         ;// @TODO: string concatenation
+      } else if (stu__checkt(STU___function, a) && stu__checkt(STU___dict, b)) {
+         stu__func *f = (stu__func *) malloc(12);
+         assert(offsetof(stu__func, code)==12);
+         f->closure_source = a;
+         f->f.closure_data = b;
+         return stu__makeobj(STU___function, f, 16, 1);
+      }
+   }
+   if (stua_overload) r = stua_overload(op,a,b,c);
+   if (stu__flow != FLOW_error && r == STUA_NO_VALUE)
+      stua_error("Typecheck for operator %d", op), r=stua_nil;
+   return r;
+}
+
+#define STU__EVAL2(a,b)             \
+          a = stu__eval(stu__f[n+1]);  if (stu__flow) break; stua_pushroot(a); \
+          b = stu__eval(stu__f[n+2]);  stua_poproot(); if (stu__flow) break;
+
+#define STU__FB(op)              \
+          STU__EVAL2(a,b)           \
+          if (stu__tag(a) == stu__int_tag && stu__tag(b) == stu__int_tag) \
+             return ((a) op (b));                 \
+          if (stu__number(a) && stu__number(b)) \
+             return stua_make_number(stua_number(a) op stua_number(b)); \
+          return stu__op(stu__f[n], a,b, stua_nil)
+
+#define STU__F(op)              \
+          STU__EVAL2(a,b)           \
+          if (stu__number(a) && stu__number(b)) \
+             return stua_make_number(stua_number(a) op stua_number(b)); \
+          return stu__op(stu__f[n], a,b, stua_nil)
+
+#define STU__I(op)               \
+          STU__EVAL2(a,b)           \
+          if (stu__tag(a) == stu__int_tag && stu__tag(b) == stu__int_tag) \
+             return stu__makeint(stu__int(a) op stu__int(b));                 \
+          return stu__op(stu__f[n], a,b, stua_nil)
+
+#define STU__C(op)               \
+          STU__EVAL2(a,b)           \
+          if (stu__number(a) && stu__number(b)) \
+             return (stua_number(a) op stua_number(b)) ? stua_true : stua_false; \
+          return stu__op(stu__f[n], a,b, stua_nil)
+
+#define STU__CE(op)              \
+          STU__EVAL2(a,b)           \
+          return (a op b) ? stua_true : stua_false
+
+static short *stu__f;
+static stua_obj  stu__f_obj;
+static stua_dict       *stu__c;
+static stua_obj stu__funceval(stua_obj fo, stua_obj co);
+
+static int stu__cond(stua_obj x)
+{
+   if (stu__flow) return 0;
+   if (!stu__checkt(STU___boolean, x))
+      x = stu__op('!', x, stua_nil, stua_nil);
+   if (x == stua_true ) return 1;
+   if (x == stua_false) return 0;
+   stu__flow = FLOW_error;
+   return 0;
+}
+
+// had to manually eliminate tailcall recursion for debugging complex stuff
+#define TAILCALL(x)   n = (x); goto top;
+static stua_obj stu__eval(int n)
+{
+top:
+   if (stu__flow >= FLOW_return) return stua_nil; // is this needed?
+   if (n < 0) return stu__const(stu__f)[n];
+   assert(n != 0 && n != 1);
+   switch (stu__f[n]) {
+      stua_obj a,b,c;
+      case ST_catch:   a = stu__eval(stu__f[n+1]);
+                       if (stu__flow == FLOW_error) { a=stu__flow_val; stu__flow = FLOW_normal; }
+                       return a;
+      case ST_var:     b = stu__eval(stu__f[n+2]); if (stu__flow) break;
+                       stu__set(stu__c, stu__const(stu__f)[stu__f[n+1]], b);
+                       return b;
+      case STU__seq:   stu__eval(stu__f[n+1]); if (stu__flow) break;
+                       TAILCALL(stu__f[n+2]);
+      case ST_if:      if (!stu__cond(stu__eval(stu__f[n+1]))) return stua_nil;
+                       TAILCALL(stu__f[n+2]);
+      case ST_else:    a = stu__cond(stu__eval(stu__f[n+1]));
+                       TAILCALL(stu__f[n + 2 + !a]);
+                       #define STU__HANDLE_BREAK            \
+                          if (stu__flow >= FLOW_break) {    \
+                             if (stu__flow == FLOW_break) { \
+                                a = stu__flow_val;          \
+                                stu__flow = FLOW_normal;    \
+                                stu__flow_val = stua_nil;   \
+                                return a;                   \
+                             }                              \
+                             return stua_nil;               \
+                          }
+      case ST_as:      stu__eval(stu__f[n+3]);
+                       STU__HANDLE_BREAK
+                       // fallthrough!
+      case ST_while:   a = stua_nil; stua_pushroot(a);
+                       while (stu__cond(stu__eval(stu__f[n+1]))) {
+                          stua_poproot();
+                          a = stu__eval(stu__f[n+2]);
+                          STU__HANDLE_BREAK
+                          stu__flow = FLOW_normal;  // clear 'continue' flag
+                          stua_pushroot(a);
+                          if (stu__f[n+3]) stu__eval(stu__f[n+3]);
+                          STU__HANDLE_BREAK
+                          stu__flow = FLOW_normal;  // clear 'continue' flag
+                       }
+                       stua_poproot();
+                       return a;
+      case ST_break:   stu__flow = FLOW_break;  stu__flow_val = stu__eval(stu__f[n+1]); break;
+      case ST_continue:stu__flow = FLOW_continue; break;
+      case ST_return:  stu__flow = FLOW_return; stu__flow_val = stu__eval(stu__f[n+1]); break;
+      case ST__frame:  return stu__f_obj;
+      case '[':        STU__EVAL2(a,b);
+                       if (stu__checkt(STU___dict, a))
+                          return stu__get(stu__pd(a), b, stua_nil);
+                       return stu__op(stu__f[n], a, b, stua_nil);
+      case '=':        a = stu__eval(stu__f[n+2]); if (stu__flow) break;
+                       n = stu__f[n+1];
+                       if (stu__f[n] == ST_id) {
+                          if (!stb_idict_update(stu__c, stu__const(stu__f)[stu__f[n+1]], a))
+                             if (!stb_idict_update(stu__globaldict, stu__const(stu__f)[stu__f[n+1]], a))
+                                return stua_error("Assignment to undefined variable");
+                       } else if (stu__f[n] == '[') {
+                          stua_pushroot(a);
+                          b = stu__eval(stu__f[n+1]); if (stu__flow) { stua_poproot(); break; }
+                          stua_pushroot(b);
+                          c = stu__eval(stu__f[n+2]); stua_poproot(); stua_poproot();
+                          if (stu__flow) break;
+                          if (!stu__checkt(STU___dict, b)) return stua_nil;
+                          stu__set(stu__pd(b), c, a);
+                       } else {
+                          return stu__op(stu__f[n], stu__eval(n), a, stua_nil);
+                       }
+                       return a;
+      case STU__defaultparm:
+                       a = stu__eval(stu__f[n+2]);
+                       stu__flow = FLOW_normal;
+                       if (stb_idict_add(stu__c, stu__const(stu__f)[stu__f[n+1]], a))
+                          stu__size_allocs += 8;
+                       return stua_nil;
+      case ST_id:      a = stu__get(stu__c, stu__const(stu__f)[stu__f[n+1]], STUA_NO_VALUE); // try local variable
+                       return a != STUA_NO_VALUE       // else try stu__compile_global_scope variable
+                            ? a : stu__get(stu__globaldict, stu__const(stu__f)[stu__f[n+1]], stua_nil);
+      case STU__negate:a = stu__eval(stu__f[n+1]); if (stu__flow) break;
+                       return stu__isint(a) ? -a : stu__op(stu__f[n], a, stua_nil, stua_nil);
+      case '~':        a = stu__eval(stu__f[n+1]); if (stu__flow) break;
+                       return stu__isint(a) ? (~a)&~3 : stu__op(stu__f[n], a, stua_nil, stua_nil);
+      case '!':        a = stu__eval(stu__f[n+1]); if (stu__flow) break;
+                       a = stu__cond(a); if (stu__flow) break;
+                       return a ? stua_true : stua_false;
+      case ST_eq: STU__CE(==); case ST_le: STU__C(<=); case '<': STU__C(<);
+      case ST_ne: STU__CE(!=); case ST_ge: STU__C(>=); case '>': STU__C(>);
+      case '+' : STU__FB(+);  case '*': STU__F(*);  case '&': STU__I(&); case ST_shl: STU__I(<<);
+      case '-' : STU__FB(-);  case '/': STU__F(/);  case '|': STU__I(|); case ST_shr: STU__I(>>);
+                             case '%': STU__I(%);  case '^': STU__I(^);
+      case ST_shru:    STU__EVAL2(a,b);
+                       if (stu__tag(a) == stu__int_tag && stu__tag(b) == stu__int_tag)
+                          return stu__makeint((unsigned) stu__int(a) >> stu__int(b));
+                       return stu__op(stu__f[n], a,b, stua_nil);
+      case ST_and:      a = stu__eval(stu__f[n+1]); b = stu__cond(a); if (stu__flow) break;
+                       return a ? stu__eval(stu__f[n+2]) : a;
+      case ST_or :      a = stu__eval(stu__f[n+1]); b = stu__cond(a); if (stu__flow) break;
+                       return a ? b : stu__eval(stu__f[n+2]);
+      case'(':case':': STU__EVAL2(a,b);
+                       if (!stu__checkt(STU___function, a))
+                           return stu__op(stu__f[n], a,b, stua_nil);
+                       if (!stu__checkt(STU___dict, b))
+                           return stua_nil;
+                       if (stu__f[n] == ':')
+                          b = stu__makeobj(STU___dict, stb_idict_copy(stu__pd(b)), stb_idict_memory_usage(stu__pd(b)), 0);
+                       a = stu__funceval(a,b);
+                       return a;
+      case '{' :    {
+                       stua_dict *d;
+                       d = stb_idict_new_size(stu__f[n+1] > 40 ? 64 : 16);
+                       if (d == NULL)
+                          return stua_nil; // breakpoint fodder
+                       c = stu__makeobj(STU___dict, d, 32, 1);
+                       stua_pushroot(c);
+                       a = stu__f[n+1];
+                       for (b=0; b < a; ++b) {
+                          stua_obj x = stua_pushroot(stu__eval(stu__f[n+2 + b*2 + 0]));
+                          stua_obj y = stu__eval(stu__f[n+2 + b*2 + 1]);
+                          stua_poproot();
+                          if (stu__flow) { stua_poproot(); return stua_nil; }
+                          stu__set(d, x, y);
+                       }
+                       stua_poproot();
+                       return c;
+                    }
+      default:         if (stu__f[n] < 0) return stu__const(stu__f)[stu__f[n]];
+                       assert(0); /* NOTREACHED */ // internal error!
+   }
+   return stua_nil;
+}
+
+int stb__stua_nesting;
+static stua_obj stu__funceval(stua_obj fo, stua_obj co)
+{
+   stu__func *f = stu__pf(fo);
+   stua_dict *context = stu__pd(co);
+   int i,j;
+   stua_obj p;
+   short *tf = stu__f;     // save previous function
+   stua_dict *tc = stu__c;
+
+   if (stu__flow == FLOW_error) return stua_nil;
+   assert(stu__flow == FLOW_normal);
+
+   stua_pushroot(fo);
+   stua_pushroot(co);
+   stu__consider_gc(stua_nil);
+
+   while ((stb_uint) f->closure_source > 4) {
+      // add data from closure to context
+      stua_dict *e = (stua_dict *) stu__pd(f->f.closure_data);
+      for (i=0; i < e->limit; ++i)
+         if (e->table[i].k != STB_IEMPTY && e->table[i].k != STB_IDEL)
+            if (stb_idict_add(context, e->table[i].k, e->table[i].v))
+               stu__size_allocs += 8;
+            // use add so if it's already defined, we don't override it; that way
+            // explicit parameters win over applied ones, and most recent applications
+            // win over previous ones
+      f = stu__pf(f->closure_source);
+   }
+
+   for (j=0, i=0; i < f->num_param; ++i)
+      // if it doesn't already exist, add it from the numbered parameters
+      if (stb_idict_add(context, f->param[i], stu__get(context, stu__int(j), stua_nil)))
+         ++j;
+
+   // @TODO: if (stu__get(context, stu__int(f->num_param+1)) != STUA_NO_VALUE) // error: too many parameters
+   // @TODO: ditto too few parameters
+
+   if (f->closure_source == 4)
+      p = f->f.func(context);
+   else {
+      stu__f = f->code, stu__c = context;
+      stu__f_obj = co;
+      ++stb__stua_nesting;
+      if (stu__f[1]) 
+         p = stu__eval(stu__f[1]);
+      else
+         p = stua_nil;
+      --stb__stua_nesting;
+      stu__f = tf, stu__c = tc;  // restore previous function
+      if (stu__flow == FLOW_return) {
+         stu__flow = FLOW_normal;
+         p = stu__flow_val;
+         stu__flow_val = stua_nil;
+      }
+   }
+
+   stua_poproot();
+   stua_poproot();
+
+   return p;
+}
+
+// Parser
+
+static int stu__tok;
+static stua_obj stu__tokval;
+
+static char *stu__curbuf, *stu__bufstart;
+
+static stb_matcher *stu__lex_matcher;
+
+static unsigned char stu__prec[ST__max_terminals], stu__end[ST__max_terminals];
+
+static void stu__nexttoken(void)
+{
+   int len;
+
+retry:
+   stu__tok = stb_lex(stu__lex_matcher, stu__curbuf, &len);
+   if (stu__tok == 0)
+      return;
+   switch(stu__tok) {
+      case ST_white  : stu__curbuf += len; goto retry;
+      case T__none  : stu__tok = *stu__curbuf; break;
+      case ST_string:  stu__tokval = make_string(stu__curbuf+1, len-2); break;
+      case ST_id    :  stu__tokval = make_string(stu__curbuf, len); break;
+      case ST_hex    : stu__tokval = stu__makeint(strtol(stu__curbuf+2,NULL,16)); stu__tok = ST_number; break;
+      case ST_decimal: stu__tokval = stu__makeint(strtol(stu__curbuf  ,NULL,10)); stu__tok = ST_number; break;
+      case ST_float  : stu__tokval = stua_float((float) atof(stu__curbuf))       ; stu__tok = ST_number; break;
+      case ST_char   : stu__tokval = stu__curbuf[2] == '\\' ? stu__curbuf[3] : stu__curbuf[2];
+                      if (stu__curbuf[3] == 't') stu__tokval = '\t';
+                      if (stu__curbuf[3] == 'n') stu__tokval = '\n';
+                      if (stu__curbuf[3] == 'r') stu__tokval = '\r';
+                      stu__tokval = stu__makeint(stu__tokval);
+                      stu__tok  = ST_number;
+                      break;
+   }
+   stu__curbuf += len;
+}
+
+static struct { int stu__tok; char *regex; } stu__lexemes[] =
+{
+   ST_white  , "([ \t\n\r]|/\\*(.|\n)*\\*/|//[^\r\n]*([\r\n]|$))+",
+   ST_id     , "[_a-zA-Z][_a-zA-Z0-9]*",
+   ST_hex    , "0x[0-9a-fA-F]+",
+   ST_decimal, "[0-9]+[0-9]*",
+   ST_float  , "[0-9]+\\.?[0-9]*([eE][-+]?[0-9]+)?",
+   ST_float  , "\\.[0-9]+([eE][-+]?[0-9]+)?",
+   ST_char   , "c'(\\\\.|[^\\'])'",
+   ST_string , "\"(\\\\.|[^\\\"\n\r])*\"",
+   ST_string , "\'(\\\\.|[^\\\'\n\r])*\'",
+
+   #define stua_key4(a,b,c,d)  ST_##a, #a, ST_##b, #b, ST_##c, #c, ST_##d, #d,
+   stua_key4(if,then,else,elseif)    stua_key4(while,do,for,in)
+   stua_key4(func,var,let,break)     stua_key4(nil,true,false,end)
+   stua_key4(return,continue,as,repeat) stua_key4(_frame,catch,catch,catch)
+
+   ST_shl, "<<",   ST_and, "&&",  ST_eq,  "==",  ST_ge, ">=", 
+   ST_shr, ">>",   ST_or , "||",  ST_ne,  "!=",  ST_le, "<=",
+   ST_shru,">>>",  ST_into, "=>",
+   T__none, ".",
+};
+
+typedef struct
+{
+   stua_obj  *data;    // constants being compiled
+   short     *code;    // code being compiled
+   stua_dict *locals;
+   short     *non_local_refs;
+} stu__comp_func;
+
+static stu__comp_func stu__pfunc;
+static stu__comp_func *func_stack = NULL;
+static void stu__push_func_comp(void)
+{
+   stb_arr_push(func_stack, stu__pfunc);
+   stu__pfunc.data = NULL;
+   stu__pfunc.code = NULL;
+   stu__pfunc.locals = stb_idict_new_size(16);
+   stu__pfunc.non_local_refs = NULL;
+   stb_arr_push(stu__pfunc.code, 0); // number of data items
+   stb_arr_push(stu__pfunc.code, 1); // starting execution address
+}
+
+static void stu__pop_func_comp(void)
+{
+   stb_arr_free(stu__pfunc.code);
+   stb_arr_free(stu__pfunc.data);   
+   stb_idict_destroy(stu__pfunc.locals);
+   stb_arr_free(stu__pfunc.non_local_refs);
+   stu__pfunc = stb_arr_pop(func_stack);
+}
+
+// if an id is a reference to an outer lexical scope, this
+// function returns the "name" of it, and updates the stack
+// structures to make sure the names are propogated in.
+static int stu__nonlocal_id(stua_obj var_obj)
+{
+   stua_obj dummy, var = var_obj;
+   int i, n = stb_arr_len(func_stack), j,k;
+   if (stb_idict_get_flag(stu__pfunc.locals, var, &dummy)) return 0;
+   for (i=n-1; i > 1; --i) {
+      if (stb_idict_get_flag(func_stack[i].locals, var, &dummy))
+         break;
+   }
+   if (i <= 1) return 0; // stu__compile_global_scope
+   j = i; // need to access variable from j'th frame
+   for (i=0; i < stb_arr_len(stu__pfunc.non_local_refs); ++i)
+      if (stu__pfunc.non_local_refs[i] == j) return j-n;
+   stb_arr_push(stu__pfunc.non_local_refs, j-n);
+   // now make sure all the parents propogate it down
+   for (k=n-1; k > 1; --k) {
+      if (j-k >= 0) return j-n; // comes direct from this parent
+      for(i=0; i < stb_arr_len(func_stack[k].non_local_refs); ++i)
+         if (func_stack[k].non_local_refs[i] == j-k)
+            return j-n;
+      stb_arr_push(func_stack[k].non_local_refs, j-k);
+   }
+   assert (k != 1);
+
+   return j-n;
+}
+
+static int stu__off(void)                { return stb_arr_len(stu__pfunc.code); }
+static void stu__cc(int a)
+{
+   assert(a >= -2000 && a < 5000);
+   stb_arr_push(stu__pfunc.code, a);
+}
+static int stu__cc1(int a)                      { stu__cc(a); return stu__off()-1; }
+static int stu__cc2(int a, int b)               { stu__cc(a); stu__cc(b); return stu__off()-2; }
+static int stu__cc3(int a, int b, int c)        {
+ if (a == '=') assert(c != 0);
+ stu__cc(a); stu__cc(b); stu__cc(c); return stu__off()-3; }
+static int stu__cc4(int a, int b, int c, int d) { stu__cc(a); stu__cc(b); stu__cc(c); stu__cc(d); return stu__off()-4; }
+
+static int stu__cdv(stua_obj p)
+{
+   int i;
+   assert(p != STUA_NO_VALUE);
+   for (i=0; i < stb_arr_len(stu__pfunc.data); ++i)
+      if (stu__pfunc.data[i] == p)
+         break;
+   if (i == stb_arr_len(stu__pfunc.data))
+      stb_arr_push(stu__pfunc.data, p);
+   return ~i;
+}
+
+static int stu__cdt(void)
+{
+   int z = stu__cdv(stu__tokval);
+   stu__nexttoken();
+   return z;
+}
+
+static int stu__seq(int a, int b)
+{
+   return !a ? b : !b ? a : stu__cc3(STU__seq, a,b);
+}
+
+static char stu__comp_err_str[1024];
+static int stu__comp_err_line;
+static int stu__err(char *str, ...)
+{
+   va_list v;
+   char *s = stu__bufstart;
+   stu__comp_err_line = 1;
+   while (s < stu__curbuf) {
+      if (s[0] == '\n' || s[0] == '\r') {
+         if (s[0]+s[1] == '\n' + '\r') ++s;
+         ++stu__comp_err_line;
+      }
+      ++s;
+   }
+   va_start(v, str);
+   vsprintf(stu__comp_err_str, str, v);
+   va_end(v);
+   return 0;
+}
+
+static int stu__accept(int p)
+{
+   if (stu__tok != p) return 0;
+   stu__nexttoken();
+   return 1;
+}
+
+static int stu__demand(int p)
+{
+   if (stu__accept(p)) return 1;
+   return stu__err("Didn't find expected stu__tok");
+}
+
+static int stu__demandv(int p, stua_obj *val)
+{
+   if (stu__tok == p || p==0) {
+      *val = stu__tokval;
+      stu__nexttoken();
+      return 1;
+   } else
+      return 0;
+}
+
+static int stu__expr(int p);
+int stu__nexpr(int p) { stu__nexttoken(); return stu__expr(p); }
+static int stu__statements(int once, int as);
+
+static int stu__parse_if(void)      // parse both ST_if and ST_elseif
+{
+   int b,c,a;
+   a = stu__nexpr(1);               if (!a) return 0;
+   if (!stu__demand(ST_then))       return stu__err("expecting THEN");
+   b = stu__statements(0,0);        if (!b) return 0;
+   if (b == 1) b = -1;
+
+   if (stu__tok == ST_elseif) {
+      return stu__parse_if();
+   } else if (stu__accept(ST_else)) {
+      c = stu__statements(0,0); if (!c) return 0;
+      if (!stu__demand(ST_end)) return stu__err("expecting END after else clause");
+      return stu__cc4(ST_else, a, b, c);
+   } else {
+      if (!stu__demand(ST_end)) return stu__err("expecting END in if statement");
+      return stu__cc3(ST_if, a, b);
+   }
+}
+
+int stu__varinit(int z, int in_globals)
+{
+   int a,b;
+   stu__nexttoken();
+   while (stu__demandv(ST_id, &b)) {
+      if (!stb_idict_add(stu__pfunc.locals, b, 1))
+         if (!in_globals) return stu__err("Redefined variable %s.", stu__pw(b)->ptr);
+      if (stu__accept('=')) {
+         a = stu__expr(1);       if (!a) return 0;
+      } else
+         a = stu__cdv(stua_nil);
+      z = stu__seq(z, stu__cc3(ST_var, stu__cdv(b), a));
+      if (!stu__accept(',')) break;
+   }
+   return z;
+}
+
+static int stu__compile_unary(int z, int outparm, int require_inparm)
+{
+   int op = stu__tok, a, b;
+   stu__nexttoken();
+   if (outparm) {
+      if (require_inparm || (stu__tok && stu__tok != ST_end && stu__tok != ST_else && stu__tok != ST_elseif && stu__tok !=';')) {
+         a = stu__expr(1); if (!a) return 0;
+      } else
+         a = stu__cdv(stua_nil);
+      b = stu__cc2(op, a);
+   } else
+      b = stu__cc1(op);
+   return stu__seq(z,b);
+}
+
+static int stu__assign(void)
+{
+   int z;
+   stu__accept(ST_let);
+   z = stu__expr(1); if (!z) return 0;
+   if (stu__accept('=')) {
+      int y,p = (z >= 0 ? stu__pfunc.code[z] : 0);
+      if (z < 0 || (p != ST_id && p != '[')) return stu__err("Invalid lvalue in assignment");
+      y = stu__assign();         if (!y) return 0;
+      z = stu__cc3('=', z, y);
+   }
+   return z;
+}
+
+static int stu__statements(int once, int stop_while)
+{
+   int a,b, c, z=0;
+   for(;;) {
+      switch (stu__tok) {
+         case ST_if     : a = stu__parse_if(); if (!a) return 0;
+                          z = stu__seq(z, a);
+                          break;
+         case ST_while  : if (stop_while) return (z ? z:1);
+                          a = stu__nexpr(1); if (!a) return 0;
+                          if (stu__accept(ST_as)) c = stu__statements(0,0); else c = 0;
+                          if (!stu__demand(ST_do)) return stu__err("expecting DO");
+                          b = stu__statements(0,0); if (!b) return 0;
+                          if (!stu__demand(ST_end)) return stu__err("expecting END");
+                          if (b == 1) b = -1;
+                          z = stu__seq(z, stu__cc4(ST_while, a, b, c));
+                          break;
+         case ST_repeat : stu__nexttoken();
+                          c = stu__statements(0,1); if (!c) return 0;
+                          if (!stu__demand(ST_while)) return stu__err("expecting WHILE");
+                          a = stu__expr(1); if (!a) return 0;
+                          if (!stu__demand(ST_do)) return stu__err("expecting DO");
+                          b = stu__statements(0,0); if (!b) return 0;
+                          if (!stu__demand(ST_end)) return stu__err("expecting END");
+                          if (b == 1) b = -1;
+                          z = stu__seq(z, stu__cc4(ST_as, a, b, c));
+                          break;
+         case ST_catch  : a = stu__nexpr(1); if (!a) return 0;
+                          z = stu__seq(z, stu__cc2(ST_catch, a));
+                          break;
+         case ST_var    : z = stu__varinit(z,0); break;
+         case ST_return : z = stu__compile_unary(z,1,1); break;
+         case ST_continue:z = stu__compile_unary(z,0,0); break;
+         case ST_break  : z = stu__compile_unary(z,1,0); break;
+         case ST_into   : if (z == 0 && !once) return stu__err("=> cannot be first statement in block");
+                          a = stu__nexpr(99);
+                          b = (a >= 0? stu__pfunc.code[a] : 0);
+                          if (a < 0 || (b != ST_id && b != '[')) return stu__err("Invalid lvalue on right side of =>");
+                          z = stu__cc3('=', a, z);
+                          break;
+         default        : if (stu__end[stu__tok]) return once ? 0 : (z ? z:1);
+                          a = stu__assign(); if (!a) return 0;
+                          stu__accept(';');
+                          if (stu__tok && !stu__end[stu__tok]) {
+                             if (a < 0)
+                                return stu__err("Constant has no effect");
+                             if (stu__pfunc.code[a] != '(' && stu__pfunc.code[a] != '=')
+                                return stu__err("Expression has no effect");
+                          }
+                          z = stu__seq(z, a);
+                          break;
+      }
+      if (!z) return 0;
+      stu__accept(';');
+      if (once && stu__tok != ST_into) return z;
+   }
+}
+
+static int stu__postexpr(int z, int p);
+static int stu__dictdef(int end, int *count)
+{
+   int z,n=0,i,flags=0;
+   short *dict=NULL;
+   stu__nexttoken();
+   while (stu__tok != end) {
+      if (stu__tok == ST_id) {
+         stua_obj id = stu__tokval;
+         stu__nexttoken();
+         if (stu__tok == '=') {
+            flags |= 1;
+            stb_arr_push(dict, stu__cdv(id));
+            z = stu__nexpr(1); if (!z) return 0;
+         } else {
+            z = stu__cc2(ST_id, stu__cdv(id));
+            z = stu__postexpr(z,1); if (!z) return 0;
+            flags |= 2;
+            stb_arr_push(dict, stu__cdv(stu__makeint(n++)));
+         }
+      } else {
+         z = stu__expr(1); if (!z) return 0;
+         flags |= 2;
+         stb_arr_push(dict, stu__cdv(stu__makeint(n++)));
+      }
+      if (end != ')' && flags == 3) { z=stu__err("can't mix initialized and uninitialized defs"); goto done;}
+      stb_arr_push(dict, z);
+      if (!stu__accept(',')) break;
+   }
+   if (!stu__demand(end))
+      return stu__err(end == ')' ? "Expecting ) at end of function call" 
+                                 : "Expecting } at end of dictionary definition");
+   z = stu__cc2('{', stb_arr_len(dict)/2);
+   for (i=0; i < stb_arr_len(dict); ++i)
+      stu__cc(dict[i]);
+   if (count) *count = n;
+done:
+   stb_arr_free(dict);
+   return z;
+}
+
+static int stu__comp_id(void)
+{
+   int z,d;
+   d = stu__nonlocal_id(stu__tokval);
+   if (d == 0)
+      return z = stu__cc2(ST_id, stu__cdt());
+   // access a non-local frame by naming it with the appropriate int
+   assert(d < 0);
+   z = stu__cdv(d);            // relative frame # is the 'variable' in our local frame
+   z = stu__cc2(ST_id, z);     // now access that dictionary
+   return stu__cc3('[', z, stu__cdt()); // now access the variable from that dir
+}
+
+static stua_obj stu__funcdef(stua_obj *id, stua_obj *func);
+static int stu__expr(int p)
+{
+   int z;
+   // unary
+   switch (stu__tok) {
+      case ST_number: z = stu__cdt(); break;
+      case ST_string: z = stu__cdt(); break;  // @TODO - string concatenation like C
+      case ST_id    : z = stu__comp_id(); break;
+      case ST__frame: z = stu__cc1(ST__frame); stu__nexttoken(); break;
+      case ST_func  : z = stu__funcdef(NULL,NULL); break;
+      case ST_if    : z = stu__parse_if(); break;
+      case ST_nil   : z = stu__cdv(stua_nil); stu__nexttoken(); break;
+      case ST_true  : z = stu__cdv(stua_true); stu__nexttoken(); break;
+      case ST_false : z = stu__cdv(stua_false); stu__nexttoken(); break;
+      case '-'      : z = stu__nexpr(99); if (z) z=stu__cc2(STU__negate,z); else return z; break;
+      case '!'      : z = stu__nexpr(99); if (z) z=stu__cc2('!',z); else return z; break;
+      case '~'      : z = stu__nexpr(99); if (z) z=stu__cc2('~',z); else return z; break;
+      case '{'      : z = stu__dictdef('}', NULL); break;
+      default       : return stu__err("Unexpected token");
+      case '('      : stu__nexttoken(); z = stu__statements(0,0); if (!stu__demand(')')) return stu__err("Expecting )");
+   }
+   return stu__postexpr(z,p);
+}
+
+static int stu__postexpr(int z, int p)
+{
+   int q;
+   // postfix
+   while (stu__tok == '(' || stu__tok == '[' || stu__tok == '.') {
+      if (stu__accept('.')) {
+         // MUST be followed by a plain identifier! use [] for other stuff
+         if (stu__tok != ST_id) return stu__err("Must follow . with plain name; try [] instead");
+         z = stu__cc3('[', z, stu__cdv(stu__tokval));
+         stu__nexttoken();
+      } else if (stu__accept('[')) {
+         while (stu__tok != ']') {
+            int r = stu__expr(1); if (!r) return 0;
+            z = stu__cc3('[', z, r);
+            if (!stu__accept(',')) break;
+         }
+         if (!stu__demand(']')) return stu__err("Expecting ]");
+      } else {
+         int n, p = stu__dictdef(')', &n); if (!p) return 0;
+         #if 0 // this is incorrect!
+         if (z > 0 && stu__pfunc.code[z] == ST_id) {
+            stua_obj q = stu__get(stu__globaldict, stu__pfunc.data[-stu__pfunc.code[z+1]-1], stua_nil);
+            if (stu__checkt(STU___function, q))
+               if ((stu__pf(q))->num_param != n)
+                  return stu__err("Incorrect number of parameters");
+         }
+         #endif
+         z = stu__cc3('(', z, p);
+      }
+   }
+   // binop - this implementation taken from lcc
+   for (q=stu__prec[stu__tok]; q >= p; --q) {
+      while (stu__prec[stu__tok] == q) {
+         int o = stu__tok, y = stu__nexpr(p+1); if (!y) return 0;
+         z = stu__cc3(o,z,y);
+      }
+   }
+   return z;
+}
+
+static stua_obj stu__finish_func(stua_obj *param, int start)
+{
+   int n, size;
+   stu__func *f = (stu__func *) malloc(sizeof(*f));
+   f->closure_source = 0;
+   f->num_param = stb_arr_len(param);
+   f->param = (int *) stb_copy(param, f->num_param * sizeof(*f->param));
+   size = stb_arr_storage(stu__pfunc.code) + stb_arr_storage(stu__pfunc.data) + sizeof(*f) + 8;
+   f->f.store = malloc(stb_arr_storage(stu__pfunc.code) + stb_arr_storage(stu__pfunc.data));
+   f->code = (short *) ((char *) f->f.store + stb_arr_storage(stu__pfunc.data));
+   memcpy(f->code, stu__pfunc.code, stb_arr_storage(stu__pfunc.code));
+   f->code[1] = start;
+   f->code[0] = stb_arr_len(stu__pfunc.data);
+   for (n=0; n < f->code[0]; ++n)
+      ((stua_obj *) f->code)[-1-n] = stu__pfunc.data[n];
+   return stu__makeobj(STU___function, f, size, 0);
+}
+
+static int stu__funcdef(stua_obj *id, stua_obj *result)
+{
+   int n,z=0,i,q;
+   stua_obj *param = NULL;
+   short *nonlocal;
+   stua_obj v,f=stua_nil;
+   assert(stu__tok == ST_func);
+   stu__nexttoken();
+   if (id) { 
+      if (!stu__demandv(ST_id, id)) return stu__err("Expecting function name");
+   } else
+      stu__accept(ST_id);
+   if (!stu__demand('(')) return stu__err("Expecting ( for function parameter");
+   stu__push_func_comp();
+   while (stu__tok != ')') {
+      if (!stu__demandv(ST_id, &v)) { z=stu__err("Expecting parameter name"); goto done; }
+      stb_idict_add(stu__pfunc.locals, v, 1);
+      if (stu__tok == '=') {
+         n = stu__nexpr(1); if (!n) { z=0; goto done; }
+         z = stu__seq(z, stu__cc3(STU__defaultparm, stu__cdv(v), n));
+      } else
+         stb_arr_push(param, v);
+      if (!stu__accept(',')) break;
+   }
+   if (!stu__demand(')'))   { z=stu__err("Expecting ) at end of parameter list"); goto done; }
+   n = stu__statements(0,0);   if (!n) { z=0; goto done; }
+   if (!stu__demand(ST_end)) { z=stu__err("Expecting END at end of function"); goto done; }
+   if (n == 1) n = 0;
+   n = stu__seq(z,n);
+   f = stu__finish_func(param, n);
+   if (result) { *result = f; z=1; stu__pop_func_comp(); }
+   else {
+      nonlocal = stu__pfunc.non_local_refs;
+      stu__pfunc.non_local_refs = NULL;
+      stu__pop_func_comp();
+      z = stu__cdv(f);
+      if (nonlocal) {  // build a closure with references to the needed frames
+         short *initcode = NULL;
+         for (i=0; i < stb_arr_len(nonlocal); ++i) {
+            int k = nonlocal[i], p;
+            stb_arr_push(initcode, stu__cdv(k));
+            if (k == -1) p = stu__cc1(ST__frame);
+            else { p = stu__cdv(stu__makeint(k+1)); p = stu__cc2(ST_id, p); }
+            stb_arr_push(initcode, p);
+         }
+         q = stu__cc2('{', stb_arr_len(nonlocal));
+         for (i=0; i < stb_arr_len(initcode); ++i)
+            stu__cc(initcode[i]);
+         z = stu__cc3('+', z, q);
+         stb_arr_free(initcode);
+      }
+      stb_arr_free(nonlocal);
+   }
+done:
+   stb_arr_free(param);
+   if (!z) stu__pop_func_comp();
+   return z;
+}
+
+static int stu__compile_global_scope(void)
+{
+   stua_obj o;
+   int z=0;
+
+   stu__push_func_comp();
+   while (stu__tok != 0) {
+      if (stu__tok == ST_func) {
+         stua_obj id, f;
+         if (!stu__funcdef(&id,&f))
+            goto error;
+         stu__set(stu__globaldict, id, f);
+      } else if (stu__tok == ST_var) {
+         z = stu__varinit(z,1); if (!z) goto error;
+      } else {
+         int y = stu__statements(1,0); if (!y) goto error;
+         z = stu__seq(z,y);
+      }
+      stu__accept(';');
+   }
+   o = stu__finish_func(NULL, z);
+   stu__pop_func_comp();
+
+   o = stu__funceval(o, stua_globals); // initialize stu__globaldict
+   if (stu__flow == FLOW_error)
+      printf("Error: %s\n", ((stu__wrapper *) stu__ptr(stu__flow_val))->ptr);
+   return 1;
+error:
+   stu__pop_func_comp();
+   return 0;
+}
+
+stua_obj stu__myprint(stua_dict *context)
+{
+   stua_obj x = stu__get(context, stua_string("x"), stua_nil);
+   if ((x & 1) == stu__float_tag) printf("%f", stu__getfloat(x));
+   else if (stu__tag(x) == stu__int_tag) printf("%d", stu__int(x));
+   else {
+       stu__wrapper *s = stu__pw(x);
+       if (s->type == STU___string || s->type == STU___error)
+          printf("%s", s->ptr);
+       else if (s->type == STU___dict) printf("{{dictionary}}");
+       else if (s->type == STU___function) printf("[[function]]");
+       else
+          printf("[[ERROR:%s]]", s->ptr);
+   }
+   return x;
+}
+
+void stua_init(void)
+{
+   if (!stu__globaldict) {
+      int i;
+      stua_obj s;
+      stu__func *f;
+
+      stu__prec[ST_and] = stu__prec[ST_or] =                     1;
+      stu__prec[ST_eq ] = stu__prec[ST_ne] = stu__prec[ST_le] =
+       stu__prec[ST_ge] = stu__prec['>' ]  = stu__prec['<'] =    2;
+      stu__prec[':']    =                                        3;
+      stu__prec['&']    = stu__prec['|']   = stu__prec['^'] =    4;
+      stu__prec['+']    = stu__prec['-']   =                     5;
+      stu__prec['*']    = stu__prec['/']   = stu__prec['%'] =
+       stu__prec[ST_shl]= stu__prec[ST_shr]= stu__prec[ST_shru]= 6;
+
+      stu__end[')']   = stu__end[ST_end] = stu__end[ST_else] = 1;
+      stu__end[ST_do] = stu__end[ST_elseif] = 1;
+
+      stu__float_init();
+      stu__lex_matcher = stb_lex_matcher();
+      for (i=0; i < sizeof(stu__lexemes)/sizeof(stu__lexemes[0]); ++i)
+         stb_lex_item(stu__lex_matcher, stu__lexemes[i].regex, stu__lexemes[i].stu__tok);
+
+      stu__globaldict = stb_idict_new_size(64);
+      stua_globals    = stu__makeobj(STU___dict, stu__globaldict, 0,0);
+      stu__strings    = stb_sdict_new(0);
+
+      stu__curbuf = stu__bufstart = "func _print(x) end\n"
+      "func print()\n  var x=0 while _frame[x] != nil as x=x+1 do _print(_frame[x]) end end\n";
+      stu__nexttoken();
+      if (!stu__compile_global_scope())
+         printf("Compile error in line %d: %s\n", stu__comp_err_line, stu__comp_err_str);
+
+      s = stu__get(stu__globaldict, stua_string("_print"), stua_nil);
+      if (stu__tag(s) == stu__ptr_tag && stu__ptr(s)->type == STU___function) {
+         f = stu__pf(s);
+         free(f->f.store);
+         f->closure_source = 4;
+         f->f.func = stu__myprint;
+         f->code = NULL;
+      }
+   }
+}
+
+void stua_uninit(void)
+{
+   if (stu__globaldict) {
+      stb_idict_remove_all(stu__globaldict);
+      stb_arr_setlen(stu__gc_root_stack, 0);
+      stua_gc(1);
+      stb_idict_destroy(stu__globaldict);
+      stb_sdict_delete(stu__strings);
+      stb_matcher_free(stu__lex_matcher);
+      stb_arr_free(stu__gc_ptrlist);
+      stb_arr_free(func_stack);
+      stb_arr_free(stu__gc_root_stack);
+      stu__globaldict = NULL;
+   }
+}
+
+void stua_run_script(char *s)
+{
+   stua_init();
+
+   stu__curbuf = stu__bufstart = s;
+   stu__nexttoken();
+
+   stu__flow = FLOW_normal;
+
+   if (!stu__compile_global_scope())
+      printf("Compile error in line %d: %s\n", stu__comp_err_line, stu__comp_err_str);
+   stua_gc(1);
+}
+#endif // STB_DEFINE
+
+#endif // STB_STUA
+
+
+#undef STB_EXTERN
+#endif // STB_INCLUDE_STB_H
+

stb_c_lexer.h

@@ -0,0 +1,806 @@
+// stb_c_lexer.h 0.04 -- public domain Sean Barrett 2013
+// lexer for making little C-like languages with recursive-descent parsers
+//
+// This file provides both the interface and the implementation.
+// To instantiate the implementation,
+//      #define STB_C_LEXER_IMPLEMENTATION
+// in *ONE* source file, before #including this file.
+//
+// The default configuration is fairly close to a C lexer, although
+// suffixes on integer constants are not handled (you can override this).
+//
+// History:
+//     0.04
+//        fix octal parsing bug
+//     0.03
+//        added STB_C_LEX_DISCARD_PREPROCESSOR option
+//        refactor API to simplify (only one struct instead of two)
+//        change literal enum names to have 'lit' at the end
+//     0.02
+//        first public release
+//
+// Status:
+//     - haven't tested compiling as C++
+//     - haven't tested the float parsing path
+//     - maybe tested "get_location" function (used for error reporting) in 0.03
+//     - haven't tested the non-default-config paths (e.g. non-stdlib)
+//     - only tested default-config paths by eyeballing output of self-parse
+//
+//     - haven't implemented multiline strings
+//     - haven't implemented octal/hex character constants
+//     - haven't implemented support for unicode CLEX_char
+//     - need to expand error reporting so you don't just get "CLEX_parse_error"
+
+#ifndef STB_C_LEXER_DEFINITIONS
+// to change the default parsing rules, copy the following lines
+// into your C/C++ file *before* including this, and then replace
+// the Y's with N's for the ones you don't want.
+// --BEGIN--
+
+#define STB_C_LEX_C_DECIMAL_INTS    Y   //  "0|[1-9][0-9]*"                        CLEX_intlit
+#define STB_C_LEX_C_HEX_INTS        Y   //  "0x[0-9a-fA-F]+"                       CLEX_intlit
+#define STB_C_LEX_C_OCTAL_INTS      Y   //  "[0-7]+"                               CLEX_intlit
+#define STB_C_LEX_C_DECIMAL_FLOATS  Y   //  "[0-9]*(.[0-9]*([eE]-?[0-9]+)?)        CLEX_floatlit
+#define STB_C_LEX_C_IDENTIFIERS     Y   //  "[_a-zA-Z][_a-zA-Z0-9]*"               CLEX_id
+#define STB_C_LEX_C_DQ_STRINGS      Y   //  double-quote-delimited strings with escapes  CLEX_dqstring
+#define STB_C_LEX_C_SQ_STRINGS      N   //  single-quote-delimited strings with escapes  CLEX_ssstring
+#define STB_C_LEX_C_CHARS           Y   //  single-quote-delimited character with escape CLEX_charlits
+#define STB_C_LEX_C_COMMENTS        Y   //  "/* comment */"
+#define STB_C_LEX_CPP_COMMENTS      Y   //  "// comment to end of line\n"
+#define STB_C_LEX_C_COMPARISONS     Y   //  "==" CLEX_eq  "!=" CLEX_noteq   "<=" CLEX_lesseq  ">=" CLEX_greatereq
+#define STB_C_LEX_C_LOGICAL         Y   //  "&&"  CLEX_andand   "||"  CLEX_oror
+#define STB_C_LEX_C_SHIFTS          Y   //  "<<"  CLEX_shl      ">>"  CLEX_shr
+#define STB_C_LEX_C_INCREMENTS      Y   //  "++"  CLEX_plusplus "--"  CLEX_minusminus
+#define STB_C_LEX_C_ARROW           Y   //  "->"  CLEX_arrow
+#define STB_C_LEX_EQUAL_ARROW       N   //  "=>"  CLEX_eqarrow
+#define STB_C_LEX_C_BITWISEEQ       Y   //  "&="  CLEX_andeq    "|="  CLEX_oreq     "^="  CLEX_xoreq
+#define STB_C_LEX_C_ARITHEQ         Y   //  "+="  CLEX_pluseq   "-="  CLEX_minuseq
+                                        //  "*="  CLEX_muleq    "/="  CLEX_diveq    "%=" CLEX_modeq
+                                        //  if both STB_C_LEX_SHIFTS & STB_C_LEX_ARITHEQ:
+                                        //                      "<<=" CLEX_shleq    ">>=" CLEX_shreq
+
+#define STB_C_LEX_PARSE_SUFFIXES    N   // letters after numbers are parsed as part of those numbers, and must be in suffix list below
+#define STB_C_LEX_DECIMAL_SUFFIXES  ""  // decimal integer suffixes e.g. "uUlL" -- these are returned as-is in string storage
+#define STB_C_LEX_HEX_SUFFIXES      ""  // e.g. "uUlL"
+#define STB_C_LEX_OCTAL_SUFFIXES    ""  // e.g. "uUlL"
+#define STB_C_LEX_FLOAT_SUFFIXES    ""  //
+
+#define STB_C_LEX_0_IS_EOF             N  // if Y, ends parsing at '\0'; if N, returns '\0' as token
+#define STB_C_LEX_INTEGERS_AS_DOUBLES  N  // parses integers as doubles so they can be larger than 'int', but only if STB_C_LEX_STDLIB==N
+#define STB_C_LEX_MULTILINE_DSTRINGS   N  // allow newlines in double-quoted strings
+#define STB_C_LEX_MULTILINE_SSTRINGS   N  // allow newlines in single-quoted strings
+#define STB_C_LEX_USE_STDLIB           Y  // use strtod,strtol for parsing #s; otherwise inaccurate hack
+#define STB_C_LEX_DOLLAR_IDENTIFIER    Y  // allow $ as an identifier character
+#define STB_C_LEX_FLOAT_NO_DECIMAL     Y  // allow floats that have no decimal point if they have an exponent
+
+#define STB_C_LEX_DEFINE_ALL_TOKEN_NAMES  N   // if Y, all CLEX_ token names are defined, even if never returned
+                                              // leaving it as N should help you catch config bugs
+
+#define STB_C_LEX_DISCARD_PREPROCESSOR    Y   // discard C-preprocessor directives (e.g. after prepocess
+                                              // still have #line, #pragma, etc)
+
+//#define STB_C_LEX_ISWHITE(str)    ... // return length in bytes of first character if it is whitespace
+
+#define STB_C_LEXER_DEFINITIONS         // This line prevents the header file from replacing your definitions
+// --END--
+
+#endif
+
+#ifndef INCLUDE_STB_C_LEXER_H
+#define INCLUDE_STB_C_LEXER_H
+
+typedef struct
+{
+   // lexer variables
+   char *input_stream;
+   char *eof;
+   char *parse_point;
+   char *string_storage;
+   int   string_storage_len;
+
+   // lexer parse location for error messages
+   char *where_firstchar;
+   char *where_lastchar;
+
+   // lexer token variables
+   long token;
+   double real_number;
+   long   int_number;
+   char *string;
+   int string_len;
+} stb_lexer;
+
+typedef struct
+{
+   int line_number;
+   int line_offset;
+} stb_lex_location;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length);
+// this function initialize the 'lexer' structure
+//   Input:
+//   - input_stream points to the file to parse, loaded into memory
+//   - input_stream_end points to the end of the file, or NULL if you use 0-for-EOF
+//   - string_store is storage the lexer can use for storing parsed strings and identifiers
+//   - store_length is the length of that storage
+
+extern int stb_c_lexer_get_token(stb_lexer *lexer);
+// this function returns non-zero if a token is parsed, or 0 if at EOF
+//   Output:
+//   - lexer->token is the token ID, which is unicode code point for a single-char token, < 0 for a multichar or eof or error
+//   - lexer->real_number is a double constant value for CLEX_floatlit, or CLEX_intlit if STB_C_LEX_INTEGERS_AS_DOUBLES
+//   - lexer->int_number is an integer constant for CLEX_intlit if !STB_C_LEX_INTEGERS_AS_DOUBLES, or character for CLEX_charlit
+//   - lexer->string is a 0-terminated string for CLEX_dqstring or CLEX_sqstring or CLEX_identifier
+//   - lexer->string_len is the byte length of lexer->string
+
+extern void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc);
+// this inefficient function returns the line number and character offset of a
+// given location in the file as returned by stb_lex_token. Because it's inefficient,
+// you should only call it for errors, not for every token.
+// For error messages of invalid tokens, you typically want the location of the start
+// of the token (which caused the token to be invalid). For bugs involving legit
+// tokens, you can report the first or the range.
+//    Output:
+//    - loc->line_number is the line number in the file, counting from 1, of the location
+//    - loc->line_offset is the char-offset in the line, counting from 0, of the location
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // INCLUDE_STB_C_LEXER_H
+
+#ifdef STB_C_LEXER_IMPLEMENTATION
+
+   #if defined(Y) || defined(N)
+   #error "Can only use stb_c_lex in contexts where the preprocessor symbols 'Y' and 'N' are not defined"
+   #endif
+
+
+// Hacky definitions so we can easily #if on them
+#define Y(x) 1
+#define N(x) 0
+
+#if STB_C_LEX_USE_STDLIB(x)
+#define STB__CLEX_use_stdlib
+#include <stdlib.h>
+#endif
+
+#if STB_C_LEX_INTEGERS_AS_DOUBLES(x)
+typedef double     stb__clex_int;
+#define intfield   real_number
+#define STB__clex_int_as_double
+#else
+typedef long       stb__clex_int;
+#define intfield   int_number
+#endif
+
+// Convert these config options to simple conditional #defines so we can more
+// easily test them once we've change the meaning of Y/N
+
+#if STB_C_LEX_PARSE_SUFFIXES(x)
+#define STB__clex_parse_suffixes
+#endif
+
+#if STB_C_LEX_C_DECIMAL_INTS(x) || STB_C_LEX_C_HEX_INTS(x) || STB_C_LEX_DEFINE_ALL_TOKEN_NAMES(x)
+#define STB__clex_define_int
+#endif
+
+#if (STB_C_LEX_C_ARITHEQ(x) && STB_C_LEX_C_SHIFTS(x)) || STB_C_LEX_DEFINE_ALL_TOKEN_NAMES(x)
+#define STB__clex_define_shifts
+#endif
+
+#if STB_C_LEX_C_HEX_INTS(x)
+#define STB__clex_hex_ints
+#endif
+
+#if STB_C_LEX_C_DECIMAL_INTS(x)
+#define STB__clex_decimal_ints
+#endif
+
+#if STB_C_LEX_C_OCTAL_INTS(x)
+#define STB__clex_octal_ints
+#endif
+
+#if STB_C_LEX_C_DECIMAL_FLOATS(x)
+#define STB__clex_decimal_floats
+#endif
+
+#if STB_C_LEX_DISCARD_PREPROCESSOR(x)
+#define STB__clex_discard_preprocessor
+#endif
+
+// Now pick a definition of Y/N that's conducive to
+// defining the enum of token names.
+#if STB_C_LEX_DEFINE_ALL_TOKEN_NAMES(x) || defined(STB_C_LEXER_SELF_TEST)
+  #undef  N
+  #define N(a) Y(a)
+#else
+  #undef  N
+  #define N(a)
+#endif
+
+#undef  Y
+#define Y(a) a,
+
+enum
+{
+   CLEX_eof = 256,
+   CLEX_parse_error,
+
+#ifdef STB__clex_define_int
+   CLEX_intlit,
+#endif
+
+   STB_C_LEX_C_DECIMAL_FLOATS( CLEX_floatlit    )
+   STB_C_LEX_C_IDENTIFIERS(  CLEX_id            )
+   STB_C_LEX_C_DQ_STRINGS(   CLEX_dqstring      )
+   STB_C_LEX_C_SQ_STRINGS(   CLEX_sqstring      )
+   STB_C_LEX_C_CHARS(        CLEX_charlit       )
+   STB_C_LEX_C_COMPARISONS(  CLEX_eq            )
+   STB_C_LEX_C_COMPARISONS(  CLEX_noteq         )
+   STB_C_LEX_C_COMPARISONS(  CLEX_lesseq        )
+   STB_C_LEX_C_COMPARISONS(  CLEX_greatereq     )
+   STB_C_LEX_C_LOGICAL(      CLEX_andand        )
+   STB_C_LEX_C_LOGICAL(      CLEX_oror          )
+   STB_C_LEX_C_SHIFTS(       CLEX_shl           )
+   STB_C_LEX_C_SHIFTS(       CLEX_shr           )
+   STB_C_LEX_C_INCREMENTS(   CLEX_plusplus      )
+   STB_C_LEX_C_INCREMENTS(   CLEX_minusminus    )
+   STB_C_LEX_C_ARITHEQ(      CLEX_pluseq        )
+   STB_C_LEX_C_ARITHEQ(      CLEX_minuseq       )
+   STB_C_LEX_C_ARITHEQ(      CLEX_muleq         )
+   STB_C_LEX_C_ARITHEQ(      CLEX_diveq         )
+   STB_C_LEX_C_ARITHEQ(      CLEX_modeq         )
+   STB_C_LEX_C_BITWISEEQ(    CLEX_andeq         )
+   STB_C_LEX_C_BITWISEEQ(    CLEX_oreq          )
+   STB_C_LEX_C_BITWISEEQ(    CLEX_xoreq         )
+   STB_C_LEX_C_ARROW(        CLEX_arrow         )
+   STB_C_LEX_EQUAL_ARROW(    CLEX_eqarrow       )
+
+#ifdef STB__clex_define_shifts
+   CLEX_shleq, CLEX_shreq, 
+#endif
+
+   CLEX_first_unused_token
+
+#undef Y
+#define Y(a) a
+};
+
+// Now for the rest of the file we'll use the basic definition where
+// where Y expands to its contents and N expands to nothing
+#undef N
+#define N(a)
+
+// API function
+void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length)
+{
+   lexer->input_stream = (char *) input_stream;
+   lexer->eof = (char *) input_stream_end;
+   lexer->parse_point = (char *) input_stream;
+   lexer->string_storage = string_store;
+   lexer->string_storage_len = store_length;
+}
+
+// API function
+void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc)
+{
+   char *p = lexer->input_stream;
+   int line_number = 1;
+   int char_offset = 0;
+   while (*p) {
+      if (*p == '\n' || *p == '\r') {
+         p += (p[0]+p[1] == '\r'+'\n' ? 2 : 1); // skip newline
+         line_number += 1;
+         char_offset = 0;
+      } else {
+         ++p;
+         ++char_offset;
+      }
+   }
+   loc->line_number = line_number;
+   loc->line_offset = char_offset;
+}
+
+// main helper function for returning a parsed token
+static int stb__clex_token(stb_lexer *lexer, int token, char *start, char *end)
+{
+   lexer->token = token;
+   lexer->where_firstchar = start;
+   lexer->where_lastchar = end;
+   lexer->parse_point = end+1;
+   return 1;
+}
+
+// helper function for returning eof
+static int stb__clex_eof(stb_lexer *lexer)
+{
+   lexer->token = CLEX_eof;
+   return 0;
+}
+
+static int stb__clex_iswhite(int x)
+{
+   return x == ' ' || x == '\t' || x == '\r' || x == '\n' || x == '\f';
+}
+
+static const char *stb__strchr(const char *str, int ch)
+{
+   for (; *str; ++str) 
+      if (*str == ch)
+         return str;
+   return 0;
+}
+
+// parse suffixes at the end of a number
+static int stb__clex_parse_suffixes(stb_lexer *lexer, long tokenid, char *start, char *cur, const char *suffixes)
+{
+   #ifdef STB__clex_parse_suffixes
+   lexer->string = lexer->string_storage;
+   lexer->string_len = 0;
+
+   while ((*cur >= 'a' && *cur <= 'z') || (*cur >= 'A' && *cur <= 'Z')) {
+      if (stb__strchr(suffixes, *cur) == 0)
+         return stb__clex_token(lexer, CLEX_parse_error, start, cur);
+      if (lexer->string_len+1 >= lexer->string_storage_len)
+         return stb__clex_token(lexer, CLEX_parse_error, start, cur);
+      lexer->string[lexer->string_len++] = *cur++;
+   }
+   #else
+   suffixes = suffixes; // attempt to suppress warnings
+   #endif
+   return stb__clex_token(lexer, tokenid, start, cur-1);
+}
+
+#ifndef STB__CLEX_use_stdlib
+static double stb__clex_parse_float(char *p, char **q)
+{
+   double value=0;
+   while (*p >= '0' && *p <= '9')
+      value = value*10 + (*p++ - '0');
+   if (*p == '.') {
+      double powten=1, addend = 0;
+      ++p;
+      while (*p >= '0' && *p <= '9') {
+         addend = addend + 10*(*p++ - '0');
+         powten *= 10;
+      }
+      value += addend / powten;
+   }
+   if (*p == 'e' || *p == 'E') {
+      int sign = p[1] == '-';
+      int exponent=0;
+      double pow10=1;
+      p += 1+sign;
+      while (*p >= '0' && *p <= '9')
+         exponent = exponent*10 + (*p++ - '0');
+      // can't use pow() from stdlib, so do it slow way
+      while (exponent-- > 0)
+         pow10 *= 10;
+      if (sign)
+         value /= pow10;
+      else
+         value *= pow10;
+   }
+   *q = p;
+   return value;
+}
+#endif
+
+static int stb__clex_parse_char(char *p, char **q)
+{
+   if (*p == '\\') {
+      *q = p+2; // tentatively guess we'll parse two characters
+      switch(p[1]) {
+         case '\\': return '\\';
+         case '\'': return '\'';
+         case '"': return '"';
+         case 't': return '\t';
+         case 'f': return '\f';
+         case 'n': return '\n';
+         case 'r': return '\r';
+         case '0': return '\0'; // @TODO ocatal constants
+         case 'x': case 'X': return -1; // @TODO hex constants
+         case 'u': return -1; // @TODO unicode constants
+      }
+   }
+   *q = p+1;
+   return (unsigned char) *p;
+}
+
+static int stb__clex_parse_string(stb_lexer *lexer, char *p, int type)
+{
+   char *start = p;
+   char delim = *p++; // grab the " or ' for later matching
+   char *out = lexer->string_storage;
+   char *outend = lexer->string_storage + lexer->string_storage_len;
+   while (*p != delim) {
+      int n;
+      if (*p == '\\') {
+         char *q;
+         n = stb__clex_parse_char(p, &q);
+         if (n < 0)
+            return stb__clex_token(lexer, CLEX_parse_error, start, q);
+         p = q;
+      } else {
+         // @OPTIMIZE: could speed this up by looping-while-not-backslash
+         n = (unsigned char) *p++;
+      }
+      if (out+1 > outend)
+         return stb__clex_token(lexer, CLEX_parse_error, start, p);
+      // @TODO expand unicode escapes to UTF8
+      *out++ = (char) n;
+   }
+   *out = 0;
+   lexer->string = lexer->string_storage;
+   lexer->string_len = out - lexer->string_storage;
+   return stb__clex_token(lexer, type, start, p+1);
+}
+
+int stb_c_lexer_get_token(stb_lexer *lexer)
+{
+   char *p = lexer->parse_point;
+
+   // skip whitespace and comments
+   for (;;) {
+      #ifdef STB_C_LEX_ISWHITE
+      while (p != lexer->stream_end) {
+         int n;
+         n = STB_C_LEX_ISWHITE(p);
+         if (n == 0) break;
+         if (lexer->eof && lexer+n > lexer->eof)
+            return stb__clex_token(tok, CLEX_parse_error, p,lexer->eof-1);
+         p += n;
+      }
+      #else
+      while (p != lexer->eof && stb__clex_iswhite(*p))
+         ++p;
+      #endif
+
+      STB_C_LEX_CPP_COMMENTS(
+         if (p != lexer->eof && p[0] == '/' && p[1] == '/') {
+            while (p != lexer->eof && *p != '\r' && *p != '\n')
+               ++p;
+            continue;
+         }
+      )
+
+      STB_C_LEX_C_COMMENTS(
+         if (p != lexer->eof && p[0] == '/' && p[1] == '*') {
+            char *start = p;
+            p += 2;
+            while (p != lexer->eof && (p[0] != '*' || p[1] != '/'))
+               ++p;
+            if (p == lexer->eof)
+               return stb__clex_token(lexer, CLEX_parse_error, start, p-1);
+            p += 2;
+            continue;
+         }
+      )
+
+      #ifdef STB__clex_discard_preprocessor
+         // @TODO this discards everything after a '#', regardless
+         // of where in the line the # is, rather than requiring it
+         // be at the start. (because this parser doesn't otherwise
+         // check for line breaks!)
+         if (p != lexer->eof && p[0] == '#') {
+            while (p != lexer->eof && *p != '\r' && *p != '\n')
+               ++p;
+            continue;
+         }
+      #endif
+
+      break;
+   }
+
+   if (p == lexer->eof)
+      return stb__clex_eof(lexer);
+
+   switch (*p) {
+      default:
+         if (   (*p >= 'a' && *p <= 'z')
+             || (*p >= 'A' && *p <= 'Z')
+             || *p == '_' || (unsigned char) *p >= 128    // >= 128 is UTF8 char
+             STB_C_LEX_DOLLAR_IDENTIFIER( || *p == '$' ) )
+         {
+            int n = 0;
+            lexer->string = lexer->string_storage;
+            lexer->string_len = n;
+            do {
+               if (n+1 >= lexer->string_storage_len)
+                  return stb__clex_token(lexer, CLEX_parse_error, p, p+n);
+               lexer->string[n] = p[n];
+               ++n;
+            } while (
+                  (p[n] >= 'a' && p[n] <= 'z')
+               || (p[n] >= 'A' && p[n] <= 'Z')
+               || (p[n] >= '0' && p[n] <= '9') // allow digits in middle of identifier
+               || p[n] == '_' || (unsigned char) p[n] >= 128
+                STB_C_LEX_DOLLAR_IDENTIFIER( || p[n] == '$' )
+            );
+            lexer->string[n] = 0;
+            return stb__clex_token(lexer, CLEX_id, p, p+n-1);
+         }
+ 
+         // check for EOF
+         STB_C_LEX_0_IS_EOF(
+            if (*p == 0)
+               return stb__clex_eof(tok);
+         )
+
+      single_char:         
+         // not an identifier, return the character as itself
+         return stb__clex_token(lexer, *p, p, p);
+
+      case '+':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_INCREMENTS(if (p[1] == '+') return stb__clex_token(lexer, CLEX_plusplus, p,p+1);)
+            STB_C_LEX_C_ARITHEQ(   if (p[1] == '=') return stb__clex_token(lexer, CLEX_pluseq  , p,p+1);)
+         }
+         goto single_char;
+      case '-':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_INCREMENTS(if (p[1] == '-') return stb__clex_token(lexer, CLEX_minusminus, p,p+1);)
+            STB_C_LEX_C_ARITHEQ(   if (p[1] == '=') return stb__clex_token(lexer, CLEX_minuseq   , p,p+1);)
+            STB_C_LEX_C_ARROW(     if (p[1] == '>') return stb__clex_token(lexer, CLEX_arrow     , p,p+1);)
+         }
+         goto single_char;
+      case '&':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_LOGICAL(  if (p[1] == '&') return stb__clex_token(lexer, CLEX_andand, p,p+1);)
+            STB_C_LEX_C_BITWISEEQ(if (p[1] == '=') return stb__clex_token(lexer, CLEX_andeq , p,p+1);)
+         }
+         goto single_char;
+      case '|':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_LOGICAL(  if (p[1] == '|') return stb__clex_token(lexer, CLEX_oror, p,p+1);)
+            STB_C_LEX_C_BITWISEEQ(if (p[1] == '=') return stb__clex_token(lexer, CLEX_oreq, p,p+1);)
+         }
+         goto single_char;
+      case '=':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_eq, p,p+1);)
+            STB_C_LEX_EQUAL_ARROW(  if (p[1] == '>') return stb__clex_token(lexer, CLEX_eqarrow, p,p+1);)
+         }
+         goto single_char;
+      case '!':
+         STB_C_LEX_C_COMPARISONS(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_noteq, p,p+1);)
+         goto single_char;
+      case '^':
+         STB_C_LEX_C_BITWISEEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_xoreq, p,p+1));
+         goto single_char;
+      case '%':
+         STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_modeq, p,p+1));
+         goto single_char;
+      case '*':
+         STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_muleq, p,p+1));
+         goto single_char;
+      case '/':
+         STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_diveq, p,p+1));
+         goto single_char;
+      case '<':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_lesseq, p,p+1);)
+            STB_C_LEX_C_SHIFTS(     if (p[1] == '<') {
+                                       STB_C_LEX_C_ARITHEQ(if (p+2 != lexer->eof && p[2] == '=')
+                                                              return stb__clex_token(lexer, CLEX_shleq, p,p+2);)
+                                       return stb__clex_token(lexer, CLEX_shl, p,p+1);
+                                    }
+                              )
+         }
+         goto single_char;
+      case '>':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_greatereq, p,p+1);)
+            STB_C_LEX_C_SHIFTS(     if (p[1] == '>') {
+                                       STB_C_LEX_C_ARITHEQ(if (p+2 != lexer->eof && p[2] == '=')
+                                                              return stb__clex_token(lexer, CLEX_shreq, p,p+2);)
+                                       return stb__clex_token(lexer, CLEX_shr, p,p+1);
+                                    }
+                              )
+         }
+         goto single_char;
+
+      case '"':
+         STB_C_LEX_C_DQ_STRINGS(return stb__clex_parse_string(lexer, p, CLEX_dqstring);)
+         goto single_char;
+      case '\'':
+         STB_C_LEX_C_SQ_STRINGS(return stb__clex_parse_string(lexer, p, CLEX_sqstring);)
+         STB_C_LEX_C_CHARS(
+         {
+            char *start = p;
+            lexer->int_number = stb__clex_parse_char(p+1, &p);
+            if (lexer->int_number < 0)
+               return stb__clex_token(lexer, CLEX_parse_error, start,start);
+            if (p == lexer->eof || *p != '\'')
+               return stb__clex_token(lexer, CLEX_parse_error, start,p);
+            return stb__clex_token(lexer, CLEX_charlit, start, p+1);
+         })
+         goto single_char;
+
+      case '0':
+         #ifdef STB__clex_hex_ints
+            if (p+1 != lexer->eof) {
+               if (p[1] == 'x' || p[1] == 'X') {
+                  char *q = p+2;
+                  #ifdef STB__CLEX_use_stdlib
+                  lexer->int_number = strtol((char *) p, (char **) q, 16);
+                  #else
+                  stb__clex_int n=0;
+                  while (q != lexer->eof) {
+                     if (*q >= '0' && *q <= '9')
+                        n = n*16 + (*q - '0');
+                     else if (*q >= 'a' && *q <= 'f')
+                        n = n*16 + (*q - 'a') + 10;
+                     else if (*q >= 'A' && *q <= 'F')
+                        n = n*16 + (*q - 'A') + 10;
+                     else
+                        break;
+                     ++q;
+                  }
+                  lexer->int_field = n; // int_field is macro that expands to real_number/int_number depending on type of n
+                  #endif
+                  if (q == p+2)
+                     return stb__clex_token(lexer, CLEX_parse_error, p-2,p-1);
+                  return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_HEX_SUFFIXES);
+               }
+            }
+         #endif // STB__clex_hex_ints
+         // can't test for octal because we might parse '0.0' as float or as '0' '.' '0',
+         // so have to do float first
+
+         /* FALL THROUGH */
+      case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+
+         #ifdef STB__clex_decimal_floats
+         {
+            char *q = p;
+            while (q != lexer->eof && (*q >= '0' && *q <= '9'))
+               ++q;
+            if (q != lexer->eof) {
+               if (*q == '.' STB_C_LEX_FLOAT_NO_DECIMAL(|| *q == 'e' || *q == 'E')) {
+                  #ifdef STB__CLEX_use_stdlib
+                  lexer->real_number = strtod((char *) p, (char**) &q);
+                  #else
+                  lexer->real_number = stb__clex_parse_float(p, &q);
+                  #endif
+
+                  return stb__clex_parse_suffixes(lexer, CLEX_floatlit, p,q, STB_C_LEX_FLOAT_SUFFIXES);
+
+               }
+            }
+         }
+         #endif // STB__clex_decimal_floats
+
+         #ifdef STB__clex_octal_ints
+         if (p[0] == '0') {
+            char *q = p;
+            #ifdef STB__CLEX_use_stdlib
+            lexer->int_number = strtol((char *) p, (char **) &q, 8);
+            #else
+            stb__clex_int n=0;
+            while (q != lexer->eof) {
+               if (*q >= '0' && *q <= '7')
+                  n = n*8 + (q - '0');
+               else
+                  break;
+               ++q;
+            }
+            if (q != lexer->eof && (*q == '8' || *q=='9'))
+               return stb__clex_token(tok, CLEX_parse_error, p, q);
+            lexer->int_field = n;
+            #endif
+            return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_OCTAL_SUFFIXES);
+         }
+         #endif // STB__clex_octal_ints
+
+         #ifdef STB__clex_decimal_ints
+         {
+            char *q = p;
+            #ifdef STB__CLEX_use_stdlib
+            lexer->int_number = strtol((char *) p, (char **) &q, 10);
+            #else
+            stb__clex_int n=0;
+            while (q != lexer->eof) {
+               if (*q >= '0' && *q <= '9')
+                  n = n*10 + (q - '0');
+               else
+                  break;
+               ++q;
+            }
+            lexer->int_field = n;
+            #endif
+            return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_OCTAL_SUFFIXES);
+         }
+         #endif // STB__clex_decimal_ints
+         goto single_char;
+   }
+}
+#endif // STB_C_LEXER_IMPLEMENTATION
+
+#ifdef STB_C_LEXER_SELF_TEST
+
+#include <stdio.h>
+
+static void print_token(stb_lexer *lexer)
+{
+   switch (lexer->token) {
+      case CLEX_id        : printf("_%s", lexer->string); break;
+      case CLEX_eq        : printf("=="); break;
+      case CLEX_noteq     : printf("!="); break;
+      case CLEX_lesseq    : printf("<="); break;
+      case CLEX_greatereq : printf(">="); break;
+      case CLEX_andand    : printf("&&"); break;
+      case CLEX_oror      : printf("||"); break;
+      case CLEX_shl       : printf("<<"); break;
+      case CLEX_shr       : printf(">>"); break;
+      case CLEX_plusplus  : printf("++"); break;
+      case CLEX_minusminus: printf("--"); break;
+      case CLEX_arrow     : printf("->"); break;
+      case CLEX_andeq     : printf("&="); break;
+      case CLEX_oreq      : printf("|="); break;
+      case CLEX_xoreq     : printf("^="); break;
+      case CLEX_pluseq    : printf("+="); break;
+      case CLEX_minuseq   : printf("-="); break;
+      case CLEX_muleq     : printf("*="); break;
+      case CLEX_diveq     : printf("/="); break;
+      case CLEX_modeq     : printf("%%="); break;
+      case CLEX_shleq     : printf("<<="); break;
+      case CLEX_shreq     : printf(">>="); break;
+      case CLEX_eqarrow   : printf("=>"); break;
+      case CLEX_dqstring  : printf("\"%s\"", lexer->string); break;
+      case CLEX_sqstring  : printf("'\"%s\"'", lexer->string); break;
+      case CLEX_charlit   : printf("'%s'", lexer->string); break;
+      #if defined(STB__clex_int_as_double) && !defined(STB__CLEX_use_stdlib)
+      case CLEX_intlit    : printf("#%g", lexer->real_number); break;
+      #else
+      case CLEX_intlit    : printf("#%ld", lexer->int_number); break;
+      #endif
+      case CLEX_floatlit  : printf("%g", lexer->real_number); break;
+      default:
+         if (lexer->token >= 0 && lexer->token < 256)
+            printf("%c", (int) lexer->token);
+         else {
+            printf("<<<UNKNOWN TOKEN %ld >>>\n", lexer->token);
+         }
+         break;
+   }
+}
+
+/* Force a test
+of parsing
+multiline comments */
+
+/*/ comment /*/
+/**/ extern /**/
+
+int main(int argc, char **argv)
+{
+   FILE *f = fopen("stb_c_lexer.h", "rb");
+   char *text = (char *) malloc(1 << 20);
+   int len = f ? fread(text, 1, 1<<20, f) : -1;
+   stb_lexer lex;
+   if (len < 0) {
+      fprintf(stderr, "Error opening file\n");
+      return 1;
+   }
+   fclose(f);
+
+   stb_c_lexer_init(&lex, text, text+len, (char *) malloc(1<<16), 1<<16);
+   while (stb_c_lexer_get_token(&lex)) {
+      if (lex.token == CLEX_parse_error) {
+         printf("\n<<<PARSE ERROR>>>\n");
+         break;
+      }
+      print_token(&lex);
+      printf("  ");
+   }
+   return 0;
+}
+#endif

stb_image.c

@@ -0,0 +1,4673 @@
+/* stbi-1.33 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
+   when you control the images you're loading
+                                     no warranty implied; use at your own risk
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline (no JPEG progressive)
+      PNG 8-bit-per-channel only
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
+
+   Latest revisions:
+      1.33 (2011-07-14) minor fixes suggested by Dave Moore
+      1.32 (2011-07-13) info support for all filetypes (SpartanJ)
+      1.31 (2011-06-19) a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30 (2011-06-11) added ability to load files via io callbacks (Ben Wenger)
+      1.29 (2010-08-16) various warning fixes from Aurelien Pocheville 
+      1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ)
+      1.27 (2010-08-01) cast-to-uint8 to fix warnings (Laurent Gomila)
+                        allow trailing 0s at end of image data (Laurent Gomila)
+      1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ
+
+   See end of file for full revision history.
+
+   TODO:
+      stbi_info support for BMP,PSD,HDR,PIC
+
+
+ ============================    Contributors    =========================
+              
+ Image formats                                Optimizations & bugfixes
+    Sean Barrett (jpeg, png, bmp)                Fabian "ryg" Giesen
+    Nicolas Schulz (hdr, psd)                                                 
+    Jonathan Dummer (tga)                     Bug fixes & warning fixes           
+    Jean-Marc Lienher (gif)                      Marc LeBlanc               
+    Tom Seddon (pic)                             Christpher Lloyd           
+    Thatcher Ulrich (psd)                        Dave Moore                 
+                                                 Won Chun                   
+                                                 the Horde3D community      
+ Extensions, features                            Janez Zemva                
+    Jetro Lauha (stbi_info)                      Jonathan Blow              
+    James "moose2000" Brown (iPhone PNG)         Laurent Gomila                             
+    Ben "Disch" Wenger (io callbacks)            Aruelien Pocheville
+    Martin "SpartanJ" Golini                     Ryamond Barbiero
+                                                 David Woo
+                                                 
+
+ If your name should be here but isn't, let Sean know.
+
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// To get a header file for this, either cut and paste the header,
+// or create stb_image.h, #define STBI_HEADER_FILE_ONLY, and
+// then include stb_image.c from it.
+
+////   begin header file  ////////////////////////////////////////////////////
+//
+// Limitations:
+//    - no jpeg progressive support
+//    - non-HDR formats support 8-bit samples only (jpeg, png)
+//    - no delayed line count (jpeg) -- IJG doesn't support either
+//    - no 1-bit BMP
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ... 
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    // ... but 'n' will always be the number that it would have been if you said 0
+//    stbi_image_free(data)
+//
+// Standard parameters:
+//    int *x       -- outputs image width in pixels
+//    int *y       -- outputs image height in pixels
+//    int *comp    -- outputs # of image components in image file
+//    int req_comp -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
+// If req_comp is non-zero, *comp has the number of components that _would_
+// have been output otherwise. E.g. if you set req_comp to 4, you will always
+// get RGBA output, but you can check *comp to easily see if it's opaque.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
+// can be queried for an extremely brief, end-user unfriendly explanation
+// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
+// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// By default we convert iphone-formatted PNGs back to RGB; nominally they
+// would silently load as BGR, except the existing code should have just
+// failed on such iPhone PNGs. But you can disable this conversion by
+// by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// you will always just get the native iphone "format" through.
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image now supports loading HDR images in general, and currently
+// the Radiance .HDR file format, although the support is provided
+// generically. You can still load any file through the existing interface;
+// if you attempt to load an HDR file, it will be automatically remapped to
+// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+// 
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead. 
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_MSC_VER) && _MSC_VER >= 0x1400
+#define _CRT_SECURE_NO_WARNINGS // suppress bogus warnings about fopen()
+#endif
+
+#include <stdio.h>
+#endif
+
+#define STBI_VERSION 1
+
+enum
+{
+   STBI_default = 0, // only used for req_comp
+
+   STBI_grey       = 1,
+   STBI_grey_alpha = 2,
+   STBI_rgb        = 3,
+   STBI_rgb_alpha  = 4
+};
+
+typedef unsigned char stbi_uc;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_STDIO
+extern stbi_uc *stbi_load            (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_load_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+typedef struct
+{
+   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read 
+   void     (*skip)  (void *user,unsigned n);            // skip the next 'n' bytes
+   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+extern stbi_uc *stbi_load_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_HDR
+   extern float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+   #ifndef STBI_NO_STDIO
+   extern float *stbi_loadf            (char const *filename,   int *x, int *y, int *comp, int req_comp);
+   extern float *stbi_loadf_from_file  (FILE *f,                int *x, int *y, int *comp, int req_comp);
+   #endif
+   
+   extern float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+   extern void   stbi_hdr_to_ldr_gamma(float gamma);
+   extern void   stbi_hdr_to_ldr_scale(float scale);
+
+   extern void   stbi_ldr_to_hdr_gamma(float gamma);
+   extern void   stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_HDR
+
+// stbi_is_hdr is always defined
+extern int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+extern int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+extern int      stbi_is_hdr          (char const *filename);
+extern int      stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// NOT THREADSAFE
+extern const char *stbi_failure_reason  (void); 
+
+// free the loaded image -- this is just free()
+extern void     stbi_image_free      (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+extern int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+extern int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+
+#ifndef STBI_NO_STDIO
+extern int      stbi_info            (char const *filename,     int *x, int *y, int *comp);
+extern int      stbi_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
+
+#endif
+
+
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+extern void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+extern void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+
+// ZLIB client - used by PNG, available for other purposes
+
+extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+extern char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+extern int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+extern char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+extern int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+// define faster low-level operations (typically SIMD support)
+#ifdef STBI_SIMD
+typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize);
+// compute an integer IDCT on "input"
+//     input[x] = data[x] * dequantize[x]
+//     write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
+//                             CLAMP results to 0..255
+typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const  *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step);
+// compute a conversion from YCbCr to RGB
+//     'count' pixels
+//     write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
+//     y: Y input channel
+//     cb: Cb input channel; scale/biased to be 0..255
+//     cr: Cr input channel; scale/biased to be 0..255
+
+extern void stbi_install_idct(stbi_idct_8x8 func);
+extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
+#endif // STBI_SIMD
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifndef STBI_HEADER_FILE_ONLY
+
+#ifndef STBI_NO_HDR
+#include <math.h>  // ldexp
+#include <string.h> // strcmp, strtok
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+#include <stdlib.h>
+#include <memory.h>
+#include <assert.h>
+#include <stdarg.h>
+
+#ifndef _MSC_VER
+   #ifdef __cplusplus
+   #define stbi_inline inline
+   #else
+   #define stbi_inline
+   #endif
+#else
+   #define stbi_inline __forceinline
+#endif
+
+
+// implementation:
+typedef unsigned char  uint8;
+typedef unsigned short uint16;
+typedef   signed short  int16;
+typedef unsigned int   uint32;
+typedef   signed int    int32;
+typedef unsigned int   uint;
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(uint32)==4 ? 1 : -1];
+
+#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE)
+#define STBI_NO_WRITE
+#endif
+
+#define STBI_NOTUSED(v)  (void)sizeof(v)
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+   #define stbi_lrot(x,y)  _lrotl(x,y)
+#else
+   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (32 - (y))))
+#endif
+
+///////////////////////////////////////////////
+//
+//  stbi struct and start_xxx functions
+
+// stbi structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+   uint32 img_x, img_y;
+   int img_n, img_out_n;
+   
+   stbi_io_callbacks io;
+   void *io_user_data;
+
+   int read_from_callbacks;
+   int buflen;
+   uint8 buffer_start[128];
+
+   uint8 *img_buffer, *img_buffer_end;
+   uint8 *img_buffer_original;
+} stbi;
+
+
+static void refill_buffer(stbi *s);
+
+// initialize a memory-decode context
+static void start_mem(stbi *s, uint8 const *buffer, int len)
+{
+   s->io.read = NULL;
+   s->read_from_callbacks = 0;
+   s->img_buffer = s->img_buffer_original = (uint8 *) buffer;
+   s->img_buffer_end = (uint8 *) buffer+len;
+}
+
+// initialize a callback-based context
+static void start_callbacks(stbi *s, stbi_io_callbacks *c, void *user)
+{
+   s->io = *c;
+   s->io_user_data = user;
+   s->buflen = sizeof(s->buffer_start);
+   s->read_from_callbacks = 1;
+   s->img_buffer_original = s->buffer_start;
+   refill_buffer(s);
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stdio_read(void *user, char *data, int size)
+{
+   return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stdio_skip(void *user, unsigned n)
+{
+   fseek((FILE*) user, n, SEEK_CUR);
+}
+
+static int stdio_eof(void *user)
+{
+   return feof((FILE*) user);
+}
+
+static stbi_io_callbacks stbi_stdio_callbacks =
+{
+   stdio_read,
+   stdio_skip,
+   stdio_eof,
+};
+
+static void start_file(stbi *s, FILE *f)
+{
+   start_callbacks(s, &stbi_stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi_rewind(stbi *s)
+{
+   // conceptually rewind SHOULD rewind to the beginning of the stream,
+   // but we just rewind to the beginning of the initial buffer, because
+   // we only use it after doing 'test', which only ever looks at at most 92 bytes
+   s->img_buffer = s->img_buffer_original;
+}
+
+static int      stbi_jpeg_test(stbi *s);
+static stbi_uc *stbi_jpeg_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_jpeg_info(stbi *s, int *x, int *y, int *comp);
+static int      stbi_png_test(stbi *s);
+static stbi_uc *stbi_png_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_png_info(stbi *s, int *x, int *y, int *comp);
+static int      stbi_bmp_test(stbi *s);
+static stbi_uc *stbi_bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_tga_test(stbi *s);
+static stbi_uc *stbi_tga_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_tga_info(stbi *s, int *x, int *y, int *comp);
+static int      stbi_psd_test(stbi *s);
+static stbi_uc *stbi_psd_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_hdr_test(stbi *s);
+static float   *stbi_hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_pic_test(stbi *s);
+static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_gif_test(stbi *s);
+static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_gif_info(stbi *s, int *x, int *y, int *comp);
+
+
+// this is not threadsafe
+static const char *failure_reason;
+
+const char *stbi_failure_reason(void)
+{
+   return failure_reason;
+}
+
+static int e(const char *str)
+{
+   failure_reason = str;
+   return 0;
+}
+
+// e - error
+// epf - error returning pointer to float
+// epuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+   #define e(x,y)  0
+#elif defined(STBI_FAILURE_USERMSG)
+   #define e(x,y)  e(y)
+#else
+   #define e(x,y)  e(x)
+#endif
+
+#define epf(x,y)   ((float *) (e(x,y)?NULL:NULL))
+#define epuc(x,y)  ((unsigned char *) (e(x,y)?NULL:NULL))
+
+void stbi_image_free(void *retval_from_stbi_load)
+{
+   free(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_HDR
+static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp);
+#endif
+
+static unsigned char *stbi_load_main(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   if (stbi_jpeg_test(s)) return stbi_jpeg_load(s,x,y,comp,req_comp);
+   if (stbi_png_test(s))  return stbi_png_load(s,x,y,comp,req_comp);
+   if (stbi_bmp_test(s))  return stbi_bmp_load(s,x,y,comp,req_comp);
+   if (stbi_gif_test(s))  return stbi_gif_load(s,x,y,comp,req_comp);
+   if (stbi_psd_test(s))  return stbi_psd_load(s,x,y,comp,req_comp);
+   if (stbi_pic_test(s))  return stbi_pic_load(s,x,y,comp,req_comp);
+
+   #ifndef STBI_NO_HDR
+   if (stbi_hdr_test(s)) {
+      float *hdr = stbi_hdr_load(s, x,y,comp,req_comp);
+      return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+   }
+   #endif
+
+   // test tga last because it's a crappy test!
+   if (stbi_tga_test(s))
+      return stbi_tga_load(s,x,y,comp,req_comp);
+   return epuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+#ifndef STBI_NO_STDIO
+unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = fopen(filename, "rb");
+   unsigned char *result;
+   if (!f) return epuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_file(&s,f);
+   return stbi_load_main(&s,x,y,comp,req_comp);
+}
+#endif //!STBI_NO_STDIO
+
+unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_mem(&s,buffer,len);
+   return stbi_load_main(&s,x,y,comp,req_comp);
+}
+
+unsigned char *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi_load_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_HDR
+
+float *stbi_loadf_main(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *data;
+   #ifndef STBI_NO_HDR
+   if (stbi_hdr_test(s))
+      return stbi_hdr_load(s,x,y,comp,req_comp);
+   #endif
+   data = stbi_load_main(s, x, y, comp, req_comp);
+   if (data)
+      return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+   return epf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_mem(&s,buffer,len);
+   return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+
+float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = fopen(filename, "rb");
+   float *result;
+   if (!f) return epf("can't fopen", "Unable to open file");
+   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_file(&s,f);
+   return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_HDR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is
+// defined, for API simplicity; if STBI_NO_HDR is defined, it always
+// reports false!
+
+int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+   #ifndef STBI_NO_HDR
+   stbi s;
+   start_mem(&s,buffer,len);
+   return stbi_hdr_test(&s);
+   #else
+   STBI_NOTUSED(buffer);
+   STBI_NOTUSED(len);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_STDIO
+extern int      stbi_is_hdr          (char const *filename)
+{
+   FILE *f = fopen(filename, "rb");
+   int result=0;
+   if (f) {
+      result = stbi_is_hdr_from_file(f);
+      fclose(f);
+   }
+   return result;
+}
+
+extern int      stbi_is_hdr_from_file(FILE *f)
+{
+   #ifndef STBI_NO_HDR
+   stbi s;
+   start_file(&s,f);
+   return stbi_hdr_test(&s);
+   #else
+   return 0;
+   #endif
+}
+#endif // !STBI_NO_STDIO
+
+extern int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+   #ifndef STBI_NO_HDR
+   stbi s;
+   start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi_hdr_test(&s);
+   #else
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_HDR
+static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f;
+static float l2h_gamma=2.2f, l2h_scale=1.0f;
+
+void   stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; }
+void   stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; }
+
+void   stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; }
+void   stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; }
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+   SCAN_load=0,
+   SCAN_type,
+   SCAN_header
+};
+
+static void refill_buffer(stbi *s)
+{
+   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+   if (n == 0) {
+      // at end of file, treat same as if from memory
+      s->read_from_callbacks = 0;
+      s->img_buffer = s->img_buffer_end-1;
+      *s->img_buffer = 0;
+   } else {
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start + n;
+   }
+}
+
+stbi_inline static int get8(stbi *s)
+{
+   if (s->img_buffer < s->img_buffer_end)
+      return *s->img_buffer++;
+   if (s->read_from_callbacks) {
+      refill_buffer(s);
+      return *s->img_buffer++;
+   }
+   return 0;
+}
+
+stbi_inline static int at_eof(stbi *s)
+{
+   if (s->io.read) {
+      if (!(s->io.eof)(s->io_user_data)) return 0;
+      // if feof() is true, check if buffer = end
+      // special case: we've only got the special 0 character at the end
+      if (s->read_from_callbacks == 0) return 1;
+   }
+
+   return s->img_buffer >= s->img_buffer_end;   
+}
+
+stbi_inline static uint8 get8u(stbi *s)
+{
+   return (uint8) get8(s);
+}
+
+static void skip(stbi *s, int n)
+{
+   if (s->io.read) {
+      int blen = s->img_buffer_end - s->img_buffer;
+      if (blen < n) {
+         s->img_buffer = s->img_buffer_end;
+         (s->io.skip)(s->io_user_data, n - blen);
+         return;
+      }
+   }
+   s->img_buffer += n;
+}
+
+static int getn(stbi *s, stbi_uc *buffer, int n)
+{
+   if (s->io.read) {
+      int blen = s->img_buffer_end - s->img_buffer;
+      if (blen < n) {
+         int res, count;
+
+         memcpy(buffer, s->img_buffer, blen);
+         
+         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
+         res = (count == (n-blen));
+         s->img_buffer = s->img_buffer_end;
+         return res;
+      }
+   }
+
+   if (s->img_buffer+n <= s->img_buffer_end) {
+      memcpy(buffer, s->img_buffer, n);
+      s->img_buffer += n;
+      return 1;
+   } else
+      return 0;
+}
+
+static int get16(stbi *s)
+{
+   int z = get8(s);
+   return (z << 8) + get8(s);
+}
+
+static uint32 get32(stbi *s)
+{
+   uint32 z = get16(s);
+   return (z << 16) + get16(s);
+}
+
+static int get16le(stbi *s)
+{
+   int z = get8(s);
+   return z + (get8(s) << 8);
+}
+
+static uint32 get32le(stbi *s)
+{
+   uint32 z = get16le(s);
+   return z + (get16le(s) << 16);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  generic converter from built-in img_n to req_comp
+//    individual types do this automatically as much as possible (e.g. jpeg
+//    does all cases internally since it needs to colorspace convert anyway,
+//    and it never has alpha, so very few cases ). png can automatically
+//    interleave an alpha=255 channel, but falls back to this for other cases
+//
+//  assume data buffer is malloced, so malloc a new one and free that one
+//  only failure mode is malloc failing
+
+static uint8 compute_y(int r, int g, int b)
+{
+   return (uint8) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+
+static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, uint x, uint y)
+{
+   int i,j;
+   unsigned char *good;
+
+   if (req_comp == img_n) return data;
+   assert(req_comp >= 1 && req_comp <= 4);
+
+   good = (unsigned char *) malloc(req_comp * x * y);
+   if (good == NULL) {
+      free(data);
+      return epuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      unsigned char *src  = data + j * x * img_n   ;
+      unsigned char *dest = good + j * x * req_comp;
+
+      #define COMBO(a,b)  ((a)*8+(b))
+      #define CASE(a,b)   case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (COMBO(img_n, req_comp)) {
+         CASE(1,2) dest[0]=src[0], dest[1]=255; break;
+         CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
+         CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
+         CASE(2,1) dest[0]=src[0]; break;
+         CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
+         CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
+         CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
+         CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
+         CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
+         CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
+         CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
+         CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
+         default: assert(0);
+      }
+      #undef CASE
+   }
+
+   free(data);
+   return good;
+}
+
+#ifndef STBI_NO_HDR
+static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+   int i,k,n;
+   float *output = (float *) malloc(x * y * comp * sizeof(float));
+   if (output == NULL) { free(data); return epf("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         output[i*comp + k] = (float) pow(data[i*comp+k]/255.0f, l2h_gamma) * l2h_scale;
+      }
+      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
+   }
+   free(data);
+   return output;
+}
+
+#define float2int(x)   ((int) (x))
+static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp)
+{
+   int i,k,n;
+   stbi_uc *output = (stbi_uc *) malloc(x * y * comp);
+   if (output == NULL) { free(data); return epuc("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         float z = (float) pow(data[i*comp+k]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (uint8) float2int(z);
+      }
+      if (k < comp) {
+         float z = data[i*comp+k] * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (uint8) float2int(z);
+      }
+   }
+   free(data);
+   return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
+//
+//    simple implementation
+//      - channel subsampling of at most 2 in each dimension
+//      - doesn't support delayed output of y-dimension
+//      - simple interface (only one output format: 8-bit interleaved RGB)
+//      - doesn't try to recover corrupt jpegs
+//      - doesn't allow partial loading, loading multiple at once
+//      - still fast on x86 (copying globals into locals doesn't help x86)
+//      - allocates lots of intermediate memory (full size of all components)
+//        - non-interleaved case requires this anyway
+//        - allows good upsampling (see next)
+//    high-quality
+//      - upsampled channels are bilinearly interpolated, even across blocks
+//      - quality integer IDCT derived from IJG's 'slow'
+//    performance
+//      - fast huffman; reasonable integer IDCT
+//      - uses a lot of intermediate memory, could cache poorly
+//      - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
+//          stb_jpeg:   1.34 seconds (MSVC6, default release build)
+//          stb_jpeg:   1.06 seconds (MSVC6, processor = Pentium Pro)
+//          IJL11.dll:  1.08 seconds (compiled by intel)
+//          IJG 1998:   0.98 seconds (MSVC6, makefile provided by IJG)
+//          IJG 1998:   0.95 seconds (MSVC6, makefile + proc=PPro)
+
+// huffman decoding acceleration
+#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+   uint8  fast[1 << FAST_BITS];
+   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+   uint16 code[256];
+   uint8  values[256];
+   uint8  size[257];
+   unsigned int maxcode[18];
+   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
+} huffman;
+
+typedef struct
+{
+   #ifdef STBI_SIMD
+   unsigned short dequant2[4][64];
+   #endif
+   stbi *s;
+   huffman huff_dc[4];
+   huffman huff_ac[4];
+   uint8 dequant[4][64];
+
+// sizes for components, interleaved MCUs
+   int img_h_max, img_v_max;
+   int img_mcu_x, img_mcu_y;
+   int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+   struct
+   {
+      int id;
+      int h,v;
+      int tq;
+      int hd,ha;
+      int dc_pred;
+
+      int x,y,w2,h2;
+      uint8 *data;
+      void *raw_data;
+      uint8 *linebuf;
+   } img_comp[4];
+
+   uint32         code_buffer; // jpeg entropy-coded buffer
+   int            code_bits;   // number of valid bits
+   unsigned char  marker;      // marker seen while filling entropy buffer
+   int            nomore;      // flag if we saw a marker so must stop
+
+   int scan_n, order[4];
+   int restart_interval, todo;
+} jpeg;
+
+static int build_huffman(huffman *h, int *count)
+{
+   int i,j,k=0,code;
+   // build size list for each symbol (from JPEG spec)
+   for (i=0; i < 16; ++i)
+      for (j=0; j < count[i]; ++j)
+         h->size[k++] = (uint8) (i+1);
+   h->size[k] = 0;
+
+   // compute actual symbols (from jpeg spec)
+   code = 0;
+   k = 0;
+   for(j=1; j <= 16; ++j) {
+      // compute delta to add to code to compute symbol id
+      h->delta[j] = k - code;
+      if (h->size[k] == j) {
+         while (h->size[k] == j)
+            h->code[k++] = (uint16) (code++);
+         if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG");
+      }
+      // compute largest code + 1 for this size, preshifted as needed later
+      h->maxcode[j] = code << (16-j);
+      code <<= 1;
+   }
+   h->maxcode[j] = 0xffffffff;
+
+   // build non-spec acceleration table; 255 is flag for not-accelerated
+   memset(h->fast, 255, 1 << FAST_BITS);
+   for (i=0; i < k; ++i) {
+      int s = h->size[i];
+      if (s <= FAST_BITS) {
+         int c = h->code[i] << (FAST_BITS-s);
+         int m = 1 << (FAST_BITS-s);
+         for (j=0; j < m; ++j) {
+            h->fast[c+j] = (uint8) i;
+         }
+      }
+   }
+   return 1;
+}
+
+static void grow_buffer_unsafe(jpeg *j)
+{
+   do {
+      int b = j->nomore ? 0 : get8(j->s);
+      if (b == 0xff) {
+         int c = get8(j->s);
+         if (c != 0) {
+            j->marker = (unsigned char) c;
+            j->nomore = 1;
+            return;
+         }
+      }
+      j->code_buffer |= b << (24 - j->code_bits);
+      j->code_bits += 8;
+   } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static uint32 bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int decode(jpeg *j, huffman *h)
+{
+   unsigned int temp;
+   int c,k;
+
+   if (j->code_bits < 16) grow_buffer_unsafe(j);
+
+   // look at the top FAST_BITS and determine what symbol ID it is,
+   // if the code is <= FAST_BITS
+   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+   k = h->fast[c];
+   if (k < 255) {
+      int s = h->size[k];
+      if (s > j->code_bits)
+         return -1;
+      j->code_buffer <<= s;
+      j->code_bits -= s;
+      return h->values[k];
+   }
+
+   // naive test is to shift the code_buffer down so k bits are
+   // valid, then test against maxcode. To speed this up, we've
+   // preshifted maxcode left so that it has (16-k) 0s at the
+   // end; in other words, regardless of the number of bits, it
+   // wants to be compared against something shifted to have 16;
+   // that way we don't need to shift inside the loop.
+   temp = j->code_buffer >> 16;
+   for (k=FAST_BITS+1 ; ; ++k)
+      if (temp < h->maxcode[k])
+         break;
+   if (k == 17) {
+      // error! code not found
+      j->code_bits -= 16;
+      return -1;
+   }
+
+   if (k > j->code_bits)
+      return -1;
+
+   // convert the huffman code to the symbol id
+   c = ((j->code_buffer >> (32 - k)) & bmask[k]) + h->delta[k];
+   assert((((j->code_buffer) >> (32 - h->size[c])) & bmask[h->size[c]]) == h->code[c]);
+
+   // convert the id to a symbol
+   j->code_bits -= k;
+   j->code_buffer <<= k;
+   return h->values[c];
+}
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int extend_receive(jpeg *j, int n)
+{
+   unsigned int m = 1 << (n-1);
+   unsigned int k;
+   if (j->code_bits < n) grow_buffer_unsafe(j);
+
+   #if 1
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~bmask[n];
+   k &= bmask[n];
+   j->code_bits -= n;
+   #else
+   k = (j->code_buffer >> (32 - n)) & bmask[n];
+   j->code_bits -= n;
+   j->code_buffer <<= n;
+   #endif
+   // the following test is probably a random branch that won't
+   // predict well. I tried to table accelerate it but failed.
+   // maybe it's compiling as a conditional move?
+   if (k < m)
+      return (-1 << n) + k + 1;
+   else
+      return k;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static uint8 dezigzag[64+15] =
+{
+    0,  1,  8, 16,  9,  2,  3, 10,
+   17, 24, 32, 25, 18, 11,  4,  5,
+   12, 19, 26, 33, 40, 48, 41, 34,
+   27, 20, 13,  6,  7, 14, 21, 28,
+   35, 42, 49, 56, 57, 50, 43, 36,
+   29, 22, 15, 23, 30, 37, 44, 51,
+   58, 59, 52, 45, 38, 31, 39, 46,
+   53, 60, 61, 54, 47, 55, 62, 63,
+   // let corrupt input sample past end
+   63, 63, 63, 63, 63, 63, 63, 63,
+   63, 63, 63, 63, 63, 63, 63
+};
+
+// decode one 64-entry block--
+static int decode_block(jpeg *j, short data[64], huffman *hdc, huffman *hac, int b)
+{
+   int diff,dc,k;
+   int t = decode(j, hdc);
+   if (t < 0) return e("bad huffman code","Corrupt JPEG");
+
+   // 0 all the ac values now so we can do it 32-bits at a time
+   memset(data,0,64*sizeof(data[0]));
+
+   diff = t ? extend_receive(j, t) : 0;
+   dc = j->img_comp[b].dc_pred + diff;
+   j->img_comp[b].dc_pred = dc;
+   data[0] = (short) dc;
+
+   // decode AC components, see JPEG spec
+   k = 1;
+   do {
+      int r,s;
+      int rs = decode(j, hac);
+      if (rs < 0) return e("bad huffman code","Corrupt JPEG");
+      s = rs & 15;
+      r = rs >> 4;
+      if (s == 0) {
+         if (rs != 0xf0) break; // end block
+         k += 16;
+      } else {
+         k += r;
+         // decode into unzigzag'd location
+         data[dezigzag[k++]] = (short) extend_receive(j,s);
+      }
+   } while (k < 64);
+   return 1;
+}
+
+// take a -128..127 value and clamp it and convert to 0..255
+stbi_inline static uint8 clamp(int x)
+{
+   // trick to use a single test to catch both cases
+   if ((unsigned int) x > 255) {
+      if (x < 0) return 0;
+      if (x > 255) return 255;
+   }
+   return (uint8) x;
+}
+
+#define f2f(x)  (int) (((x) * 4096 + 0.5))
+#define fsh(x)  ((x) << 12)
+
+// derived from jidctint -- DCT_ISLOW
+#define IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7)       \
+   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+   p2 = s2;                                    \
+   p3 = s6;                                    \
+   p1 = (p2+p3) * f2f(0.5411961f);             \
+   t2 = p1 + p3*f2f(-1.847759065f);            \
+   t3 = p1 + p2*f2f( 0.765366865f);            \
+   p2 = s0;                                    \
+   p3 = s4;                                    \
+   t0 = fsh(p2+p3);                            \
+   t1 = fsh(p2-p3);                            \
+   x0 = t0+t3;                                 \
+   x3 = t0-t3;                                 \
+   x1 = t1+t2;                                 \
+   x2 = t1-t2;                                 \
+   t0 = s7;                                    \
+   t1 = s5;                                    \
+   t2 = s3;                                    \
+   t3 = s1;                                    \
+   p3 = t0+t2;                                 \
+   p4 = t1+t3;                                 \
+   p1 = t0+t3;                                 \
+   p2 = t1+t2;                                 \
+   p5 = (p3+p4)*f2f( 1.175875602f);            \
+   t0 = t0*f2f( 0.298631336f);                 \
+   t1 = t1*f2f( 2.053119869f);                 \
+   t2 = t2*f2f( 3.072711026f);                 \
+   t3 = t3*f2f( 1.501321110f);                 \
+   p1 = p5 + p1*f2f(-0.899976223f);            \
+   p2 = p5 + p2*f2f(-2.562915447f);            \
+   p3 = p3*f2f(-1.961570560f);                 \
+   p4 = p4*f2f(-0.390180644f);                 \
+   t3 += p1+p4;                                \
+   t2 += p2+p3;                                \
+   t1 += p2+p4;                                \
+   t0 += p1+p3;
+
+#ifdef STBI_SIMD
+typedef unsigned short stbi_dequantize_t;
+#else
+typedef uint8 stbi_dequantize_t;
+#endif
+
+// .344 seconds on 3*anemones.jpg
+static void idct_block(uint8 *out, int out_stride, short data[64], stbi_dequantize_t *dequantize)
+{
+   int i,val[64],*v=val;
+   stbi_dequantize_t *dq = dequantize;
+   uint8 *o;
+   short *d = data;
+
+   // columns
+   for (i=0; i < 8; ++i,++d,++dq, ++v) {
+      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+           && d[40]==0 && d[48]==0 && d[56]==0) {
+         //    no shortcut                 0     seconds
+         //    (1|2|3|4|5|6|7)==0          0     seconds
+         //    all separate               -0.047 seconds
+         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
+         int dcterm = d[0] * dq[0] << 2;
+         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+      } else {
+         IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
+                 d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[56])
+         // constants scaled things up by 1<<12; let's bring them back
+         // down, but keep 2 extra bits of precision
+         x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+         v[ 0] = (x0+t3) >> 10;
+         v[56] = (x0-t3) >> 10;
+         v[ 8] = (x1+t2) >> 10;
+         v[48] = (x1-t2) >> 10;
+         v[16] = (x2+t1) >> 10;
+         v[40] = (x2-t1) >> 10;
+         v[24] = (x3+t0) >> 10;
+         v[32] = (x3-t0) >> 10;
+      }
+   }
+
+   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+      // no fast case since the first 1D IDCT spread components out
+      IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+      // constants scaled things up by 1<<12, plus we had 1<<2 from first
+      // loop, plus horizontal and vertical each scale by sqrt(8) so together
+      // we've got an extra 1<<3, so 1<<17 total we need to remove.
+      // so we want to round that, which means adding 0.5 * 1<<17,
+      // aka 65536. Also, we'll end up with -128 to 127 that we want
+      // to encode as 0..255 by adding 128, so we'll add that before the shift
+      x0 += 65536 + (128<<17);
+      x1 += 65536 + (128<<17);
+      x2 += 65536 + (128<<17);
+      x3 += 65536 + (128<<17);
+      // tried computing the shifts into temps, or'ing the temps to see
+      // if any were out of range, but that was slower
+      o[0] = clamp((x0+t3) >> 17);
+      o[7] = clamp((x0-t3) >> 17);
+      o[1] = clamp((x1+t2) >> 17);
+      o[6] = clamp((x1-t2) >> 17);
+      o[2] = clamp((x2+t1) >> 17);
+      o[5] = clamp((x2-t1) >> 17);
+      o[3] = clamp((x3+t0) >> 17);
+      o[4] = clamp((x3-t0) >> 17);
+   }
+}
+
+#ifdef STBI_SIMD
+static stbi_idct_8x8 stbi_idct_installed = idct_block;
+
+void stbi_install_idct(stbi_idct_8x8 func)
+{
+   stbi_idct_installed = func;
+}
+#endif
+
+#define MARKER_none  0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static uint8 get_marker(jpeg *j)
+{
+   uint8 x;
+   if (j->marker != MARKER_none) { x = j->marker; j->marker = MARKER_none; return x; }
+   x = get8u(j->s);
+   if (x != 0xff) return MARKER_none;
+   while (x == 0xff)
+      x = get8u(j->s);
+   return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, reset the entropy decoder and
+// the dc prediction
+static void reset(jpeg *j)
+{
+   j->code_bits = 0;
+   j->code_buffer = 0;
+   j->nomore = 0;
+   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0;
+   j->marker = MARKER_none;
+   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+   // since we don't even allow 1<<30 pixels
+}
+
+static int parse_entropy_coded_data(jpeg *z)
+{
+   reset(z);
+   if (z->scan_n == 1) {
+      int i,j;
+      #ifdef STBI_SIMD
+      __declspec(align(16))
+      #endif
+      short data[64];
+      int n = z->order[0];
+      // non-interleaved data, we just need to process one block at a time,
+      // in trivial scanline order
+      // number of blocks to do just depends on how many actual "pixels" this
+      // component has, independent of interleaved MCU blocking and such
+      int w = (z->img_comp[n].x+7) >> 3;
+      int h = (z->img_comp[n].y+7) >> 3;
+      for (j=0; j < h; ++j) {
+         for (i=0; i < w; ++i) {
+            if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
+            #ifdef STBI_SIMD
+            stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
+            #else
+            idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
+            #endif
+            // every data block is an MCU, so countdown the restart interval
+            if (--z->todo <= 0) {
+               if (z->code_bits < 24) grow_buffer_unsafe(z);
+               // if it's NOT a restart, then just bail, so we get corrupt data
+               // rather than no data
+               if (!RESTART(z->marker)) return 1;
+               reset(z);
+            }
+         }
+      }
+   } else { // interleaved!
+      int i,j,k,x,y;
+      short data[64];
+      for (j=0; j < z->img_mcu_y; ++j) {
+         for (i=0; i < z->img_mcu_x; ++i) {
+            // scan an interleaved mcu... process scan_n components in order
+            for (k=0; k < z->scan_n; ++k) {
+               int n = z->order[k];
+               // scan out an mcu's worth of this component; that's just determined
+               // by the basic H and V specified for the component
+               for (y=0; y < z->img_comp[n].v; ++y) {
+                  for (x=0; x < z->img_comp[n].h; ++x) {
+                     int x2 = (i*z->img_comp[n].h + x)*8;
+                     int y2 = (j*z->img_comp[n].v + y)*8;
+                     if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
+                     #ifdef STBI_SIMD
+                     stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
+                     #else
+                     idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
+                     #endif
+                  }
+               }
+            }
+            // after all interleaved components, that's an interleaved MCU,
+            // so now count down the restart interval
+            if (--z->todo <= 0) {
+               if (z->code_bits < 24) grow_buffer_unsafe(z);
+               // if it's NOT a restart, then just bail, so we get corrupt data
+               // rather than no data
+               if (!RESTART(z->marker)) return 1;
+               reset(z);
+            }
+         }
+      }
+   }
+   return 1;
+}
+
+static int process_marker(jpeg *z, int m)
+{
+   int L;
+   switch (m) {
+      case MARKER_none: // no marker found
+         return e("expected marker","Corrupt JPEG");
+
+      case 0xC2: // SOF - progressive
+         return e("progressive jpeg","JPEG format not supported (progressive)");
+
+      case 0xDD: // DRI - specify restart interval
+         if (get16(z->s) != 4) return e("bad DRI len","Corrupt JPEG");
+         z->restart_interval = get16(z->s);
+         return 1;
+
+      case 0xDB: // DQT - define quantization table
+         L = get16(z->s)-2;
+         while (L > 0) {
+            int q = get8(z->s);
+            int p = q >> 4;
+            int t = q & 15,i;
+            if (p != 0) return e("bad DQT type","Corrupt JPEG");
+            if (t > 3) return e("bad DQT table","Corrupt JPEG");
+            for (i=0; i < 64; ++i)
+               z->dequant[t][dezigzag[i]] = get8u(z->s);
+            #ifdef STBI_SIMD
+            for (i=0; i < 64; ++i)
+               z->dequant2[t][i] = z->dequant[t][i];
+            #endif
+            L -= 65;
+         }
+         return L==0;
+
+      case 0xC4: // DHT - define huffman table
+         L = get16(z->s)-2;
+         while (L > 0) {
+            uint8 *v;
+            int sizes[16],i,m=0;
+            int q = get8(z->s);
+            int tc = q >> 4;
+            int th = q & 15;
+            if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG");
+            for (i=0; i < 16; ++i) {
+               sizes[i] = get8(z->s);
+               m += sizes[i];
+            }
+            L -= 17;
+            if (tc == 0) {
+               if (!build_huffman(z->huff_dc+th, sizes)) return 0;
+               v = z->huff_dc[th].values;
+            } else {
+               if (!build_huffman(z->huff_ac+th, sizes)) return 0;
+               v = z->huff_ac[th].values;
+            }
+            for (i=0; i < m; ++i)
+               v[i] = get8u(z->s);
+            L -= m;
+         }
+         return L==0;
+   }
+   // check for comment block or APP blocks
+   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+      skip(z->s, get16(z->s)-2);
+      return 1;
+   }
+   return 0;
+}
+
+// after we see SOS
+static int process_scan_header(jpeg *z)
+{
+   int i;
+   int Ls = get16(z->s);
+   z->scan_n = get8(z->s);
+   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return e("bad SOS component count","Corrupt JPEG");
+   if (Ls != 6+2*z->scan_n) return e("bad SOS len","Corrupt JPEG");
+   for (i=0; i < z->scan_n; ++i) {
+      int id = get8(z->s), which;
+      int q = get8(z->s);
+      for (which = 0; which < z->s->img_n; ++which)
+         if (z->img_comp[which].id == id)
+            break;
+      if (which == z->s->img_n) return 0;
+      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return e("bad DC huff","Corrupt JPEG");
+      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return e("bad AC huff","Corrupt JPEG");
+      z->order[i] = which;
+   }
+   if (get8(z->s) != 0) return e("bad SOS","Corrupt JPEG");
+   get8(z->s); // should be 63, but might be 0
+   if (get8(z->s) != 0) return e("bad SOS","Corrupt JPEG");
+
+   return 1;
+}
+
+static int process_frame_header(jpeg *z, int scan)
+{
+   stbi *s = z->s;
+   int Lf,p,i,q, h_max=1,v_max=1,c;
+   Lf = get16(s);         if (Lf < 11) return e("bad SOF len","Corrupt JPEG"); // JPEG
+   p  = get8(s);          if (p != 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+   s->img_y = get16(s);   if (s->img_y == 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+   s->img_x = get16(s);   if (s->img_x == 0) return e("0 width","Corrupt JPEG"); // JPEG requires
+   c = get8(s);
+   if (c != 3 && c != 1) return e("bad component count","Corrupt JPEG");    // JFIF requires
+   s->img_n = c;
+   for (i=0; i < c; ++i) {
+      z->img_comp[i].data = NULL;
+      z->img_comp[i].linebuf = NULL;
+   }
+
+   if (Lf != 8+3*s->img_n) return e("bad SOF len","Corrupt JPEG");
+
+   for (i=0; i < s->img_n; ++i) {
+      z->img_comp[i].id = get8(s);
+      if (z->img_comp[i].id != i+1)   // JFIF requires
+         if (z->img_comp[i].id != i)  // some version of jpegtran outputs non-JFIF-compliant files!
+            return e("bad component ID","Corrupt JPEG");
+      q = get8(s);
+      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return e("bad H","Corrupt JPEG");
+      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return e("bad V","Corrupt JPEG");
+      z->img_comp[i].tq = get8(s);  if (z->img_comp[i].tq > 3) return e("bad TQ","Corrupt JPEG");
+   }
+
+   if (scan != SCAN_load) return 1;
+
+   if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode");
+
+   for (i=0; i < s->img_n; ++i) {
+      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+   }
+
+   // compute interleaved mcu info
+   z->img_h_max = h_max;
+   z->img_v_max = v_max;
+   z->img_mcu_w = h_max * 8;
+   z->img_mcu_h = v_max * 8;
+   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+   for (i=0; i < s->img_n; ++i) {
+      // number of effective pixels (e.g. for non-interleaved MCU)
+      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+      // to simplify generation, we'll allocate enough memory to decode
+      // the bogus oversized data from using interleaved MCUs and their
+      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+      // discard the extra data until colorspace conversion
+      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+      z->img_comp[i].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15);
+      if (z->img_comp[i].raw_data == NULL) {
+         for(--i; i >= 0; --i) {
+            free(z->img_comp[i].raw_data);
+            z->img_comp[i].data = NULL;
+         }
+         return e("outofmem", "Out of memory");
+      }
+      // align blocks for installable-idct using mmx/sse
+      z->img_comp[i].data = (uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+      z->img_comp[i].linebuf = NULL;
+   }
+
+   return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define DNL(x)         ((x) == 0xdc)
+#define SOI(x)         ((x) == 0xd8)
+#define EOI(x)         ((x) == 0xd9)
+#define SOF(x)         ((x) == 0xc0 || (x) == 0xc1)
+#define SOS(x)         ((x) == 0xda)
+
+static int decode_jpeg_header(jpeg *z, int scan)
+{
+   int m;
+   z->marker = MARKER_none; // initialize cached marker to empty
+   m = get_marker(z);
+   if (!SOI(m)) return e("no SOI","Corrupt JPEG");
+   if (scan == SCAN_type) return 1;
+   m = get_marker(z);
+   while (!SOF(m)) {
+      if (!process_marker(z,m)) return 0;
+      m = get_marker(z);
+      while (m == MARKER_none) {
+         // some files have extra padding after their blocks, so ok, we'll scan
+         if (at_eof(z->s)) return e("no SOF", "Corrupt JPEG");
+         m = get_marker(z);
+      }
+   }
+   if (!process_frame_header(z, scan)) return 0;
+   return 1;
+}
+
+static int decode_jpeg_image(jpeg *j)
+{
+   int m;
+   j->restart_interval = 0;
+   if (!decode_jpeg_header(j, SCAN_load)) return 0;
+   m = get_marker(j);
+   while (!EOI(m)) {
+      if (SOS(m)) {
+         if (!process_scan_header(j)) return 0;
+         if (!parse_entropy_coded_data(j)) return 0;
+         if (j->marker == MARKER_none ) {
+            // handle 0s at the end of image data from IP Kamera 9060
+            while (!at_eof(j->s)) {
+               int x = get8(j->s);
+               if (x == 255) {
+                  j->marker = get8u(j->s);
+                  break;
+               } else if (x != 0) {
+                  return 0;
+               }
+            }
+            // if we reach eof without hitting a marker, get_marker() below will fail and we'll eventually return 0
+         }
+      } else {
+         if (!process_marker(j, m)) return 0;
+      }
+      m = get_marker(j);
+   }
+   return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef uint8 *(*resample_row_func)(uint8 *out, uint8 *in0, uint8 *in1,
+                                    int w, int hs);
+
+#define div4(x) ((uint8) ((x) >> 2))
+
+static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+   STBI_NOTUSED(out);
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(w);
+   STBI_NOTUSED(hs);
+   return in_near;
+}
+
+static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+   // need to generate two samples vertically for every one in input
+   int i;
+   STBI_NOTUSED(hs);
+   for (i=0; i < w; ++i)
+      out[i] = div4(3*in_near[i] + in_far[i] + 2);
+   return out;
+}
+
+static uint8*  resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+   // need to generate two samples horizontally for every one in input
+   int i;
+   uint8 *input = in_near;
+
+   if (w == 1) {
+      // if only one sample, can't do any interpolation
+      out[0] = out[1] = input[0];
+      return out;
+   }
+
+   out[0] = input[0];
+   out[1] = div4(input[0]*3 + input[1] + 2);
+   for (i=1; i < w-1; ++i) {
+      int n = 3*input[i]+2;
+      out[i*2+0] = div4(n+input[i-1]);
+      out[i*2+1] = div4(n+input[i+1]);
+   }
+   out[i*2+0] = div4(input[w-2]*3 + input[w-1] + 2);
+   out[i*2+1] = input[w-1];
+
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#define div16(x) ((uint8) ((x) >> 4))
+
+static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i,t0,t1;
+   if (w == 1) {
+      out[0] = out[1] = div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   out[0] = div4(t1+2);
+   for (i=1; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = div16(3*t0 + t1 + 8);
+      out[i*2  ] = div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+static uint8 *resample_row_generic(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+   // resample with nearest-neighbor
+   int i,j;
+   in_far = in_far;
+   for (i=0; i < w; ++i)
+      for (j=0; j < hs; ++j)
+         out[i*hs+j] = in_near[i];
+   return out;
+}
+
+#define float2fixed(x)  ((int) ((x) * 65536 + 0.5))
+
+// 0.38 seconds on 3*anemones.jpg   (0.25 with processor = Pro)
+// VC6 without processor=Pro is generating multiple LEAs per multiply!
+static void YCbCr_to_RGB_row(uint8 *out, const uint8 *y, const uint8 *pcb, const uint8 *pcr, int count, int step)
+{
+   int i;
+   for (i=0; i < count; ++i) {
+      int y_fixed = (y[i] << 16) + 32768; // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed + cr*float2fixed(1.40200f);
+      g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
+      b = y_fixed                            + cb*float2fixed(1.77200f);
+      r >>= 16;
+      g >>= 16;
+      b >>= 16;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (uint8)r;
+      out[1] = (uint8)g;
+      out[2] = (uint8)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+
+#ifdef STBI_SIMD
+static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed = YCbCr_to_RGB_row;
+
+void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func)
+{
+   stbi_YCbCr_installed = func;
+}
+#endif
+
+
+// clean up the temporary component buffers
+static void cleanup_jpeg(jpeg *j)
+{
+   int i;
+   for (i=0; i < j->s->img_n; ++i) {
+      if (j->img_comp[i].data) {
+         free(j->img_comp[i].raw_data);
+         j->img_comp[i].data = NULL;
+      }
+      if (j->img_comp[i].linebuf) {
+         free(j->img_comp[i].linebuf);
+         j->img_comp[i].linebuf = NULL;
+      }
+   }
+}
+
+typedef struct
+{
+   resample_row_func resample;
+   uint8 *line0,*line1;
+   int hs,vs;   // expansion factor in each axis
+   int w_lores; // horizontal pixels pre-expansion 
+   int ystep;   // how far through vertical expansion we are
+   int ypos;    // which pre-expansion row we're on
+} stbi_resample;
+
+static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+   int n, decode_n;
+   // validate req_comp
+   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
+   z->s->img_n = 0;
+
+   // load a jpeg image from whichever source
+   if (!decode_jpeg_image(z)) { cleanup_jpeg(z); return NULL; }
+
+   // determine actual number of components to generate
+   n = req_comp ? req_comp : z->s->img_n;
+
+   if (z->s->img_n == 3 && n < 3)
+      decode_n = 1;
+   else
+      decode_n = z->s->img_n;
+
+   // resample and color-convert
+   {
+      int k;
+      uint i,j;
+      uint8 *output;
+      uint8 *coutput[4];
+
+      stbi_resample res_comp[4];
+
+      for (k=0; k < decode_n; ++k) {
+         stbi_resample *r = &res_comp[k];
+
+         // allocate line buffer big enough for upsampling off the edges
+         // with upsample factor of 4
+         z->img_comp[k].linebuf = (uint8 *) malloc(z->s->img_x + 3);
+         if (!z->img_comp[k].linebuf) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); }
+
+         r->hs      = z->img_h_max / z->img_comp[k].h;
+         r->vs      = z->img_v_max / z->img_comp[k].v;
+         r->ystep   = r->vs >> 1;
+         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+         r->ypos    = 0;
+         r->line0   = r->line1 = z->img_comp[k].data;
+
+         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+         else if (r->hs == 1 && r->vs == 2) r->resample = resample_row_v_2;
+         else if (r->hs == 2 && r->vs == 1) r->resample = resample_row_h_2;
+         else if (r->hs == 2 && r->vs == 2) r->resample = resample_row_hv_2;
+         else                               r->resample = resample_row_generic;
+      }
+
+      // can't error after this so, this is safe
+      output = (uint8 *) malloc(n * z->s->img_x * z->s->img_y + 1);
+      if (!output) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); }
+
+      // now go ahead and resample
+      for (j=0; j < z->s->img_y; ++j) {
+         uint8 *out = output + n * z->s->img_x * j;
+         for (k=0; k < decode_n; ++k) {
+            stbi_resample *r = &res_comp[k];
+            int y_bot = r->ystep >= (r->vs >> 1);
+            coutput[k] = r->resample(z->img_comp[k].linebuf,
+                                     y_bot ? r->line1 : r->line0,
+                                     y_bot ? r->line0 : r->line1,
+                                     r->w_lores, r->hs);
+            if (++r->ystep >= r->vs) {
+               r->ystep = 0;
+               r->line0 = r->line1;
+               if (++r->ypos < z->img_comp[k].y)
+                  r->line1 += z->img_comp[k].w2;
+            }
+         }
+         if (n >= 3) {
+            uint8 *y = coutput[0];
+            if (z->s->img_n == 3) {
+               #ifdef STBI_SIMD
+               stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n);
+               #else
+               YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               #endif
+            } else
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = out[1] = out[2] = y[i];
+                  out[3] = 255; // not used if n==3
+                  out += n;
+               }
+         } else {
+            uint8 *y = coutput[0];
+            if (n == 1)
+               for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+            else
+               for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
+         }
+      }
+      cleanup_jpeg(z);
+      *out_x = z->s->img_x;
+      *out_y = z->s->img_y;
+      if (comp) *comp  = z->s->img_n; // report original components, not output
+      return output;
+   }
+}
+
+static unsigned char *stbi_jpeg_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   jpeg j;
+   j.s = s;
+   return load_jpeg_image(&j, x,y,comp,req_comp);
+}
+
+static int stbi_jpeg_test(stbi *s)
+{
+   int r;
+   jpeg j;
+   j.s = s;
+   r = decode_jpeg_header(&j, SCAN_type);
+   stbi_rewind(s);
+   return r;
+}
+
+static int stbi_jpeg_info_raw(jpeg *j, int *x, int *y, int *comp)
+{
+   if (!decode_jpeg_header(j, SCAN_header)) {
+      stbi_rewind( j->s );
+      return 0;
+   }
+   if (x) *x = j->s->img_x;
+   if (y) *y = j->s->img_y;
+   if (comp) *comp = j->s->img_n;
+   return 1;
+}
+
+static int stbi_jpeg_info(stbi *s, int *x, int *y, int *comp)
+{
+   jpeg j;
+   j.s = s;
+   return stbi_jpeg_info_raw(&j, x, y, comp);
+}
+
+// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
+//    simple implementation
+//      - all input must be provided in an upfront buffer
+//      - all output is written to a single output buffer (can malloc/realloc)
+//    performance
+//      - fast huffman
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define ZFAST_BITS  9 // accelerate all cases in default tables
+#define ZFAST_MASK  ((1 << ZFAST_BITS) - 1)
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+   uint16 fast[1 << ZFAST_BITS];
+   uint16 firstcode[16];
+   int maxcode[17];
+   uint16 firstsymbol[16];
+   uint8  size[288];
+   uint16 value[288]; 
+} zhuffman;
+
+stbi_inline static int bitreverse16(int n)
+{
+  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
+  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
+  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
+  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
+  return n;
+}
+
+stbi_inline static int bit_reverse(int v, int bits)
+{
+   assert(bits <= 16);
+   // to bit reverse n bits, reverse 16 and shift
+   // e.g. 11 bits, bit reverse and shift away 5
+   return bitreverse16(v) >> (16-bits);
+}
+
+static int zbuild_huffman(zhuffman *z, uint8 *sizelist, int num)
+{
+   int i,k=0;
+   int code, next_code[16], sizes[17];
+
+   // DEFLATE spec for generating codes
+   memset(sizes, 0, sizeof(sizes));
+   memset(z->fast, 255, sizeof(z->fast));
+   for (i=0; i < num; ++i) 
+      ++sizes[sizelist[i]];
+   sizes[0] = 0;
+   for (i=1; i < 16; ++i)
+      assert(sizes[i] <= (1 << i));
+   code = 0;
+   for (i=1; i < 16; ++i) {
+      next_code[i] = code;
+      z->firstcode[i] = (uint16) code;
+      z->firstsymbol[i] = (uint16) k;
+      code = (code + sizes[i]);
+      if (sizes[i])
+         if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG");
+      z->maxcode[i] = code << (16-i); // preshift for inner loop
+      code <<= 1;
+      k += sizes[i];
+   }
+   z->maxcode[16] = 0x10000; // sentinel
+   for (i=0; i < num; ++i) {
+      int s = sizelist[i];
+      if (s) {
+         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+         z->size[c] = (uint8)s;
+         z->value[c] = (uint16)i;
+         if (s <= ZFAST_BITS) {
+            int k = bit_reverse(next_code[s],s);
+            while (k < (1 << ZFAST_BITS)) {
+               z->fast[k] = (uint16) c;
+               k += (1 << s);
+            }
+         }
+         ++next_code[s];
+      }
+   }
+   return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+//    because PNG allows splitting the zlib stream arbitrarily,
+//    and it's annoying structurally to have PNG call ZLIB call PNG,
+//    we require PNG read all the IDATs and combine them into a single
+//    memory buffer
+
+typedef struct
+{
+   uint8 *zbuffer, *zbuffer_end;
+   int num_bits;
+   uint32 code_buffer;
+
+   char *zout;
+   char *zout_start;
+   char *zout_end;
+   int   z_expandable;
+
+   zhuffman z_length, z_distance;
+} zbuf;
+
+stbi_inline static int zget8(zbuf *z)
+{
+   if (z->zbuffer >= z->zbuffer_end) return 0;
+   return *z->zbuffer++;
+}
+
+static void fill_bits(zbuf *z)
+{
+   do {
+      assert(z->code_buffer < (1U << z->num_bits));
+      z->code_buffer |= zget8(z) << z->num_bits;
+      z->num_bits += 8;
+   } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int zreceive(zbuf *z, int n)
+{
+   unsigned int k;
+   if (z->num_bits < n) fill_bits(z);
+   k = z->code_buffer & ((1 << n) - 1);
+   z->code_buffer >>= n;
+   z->num_bits -= n;
+   return k;   
+}
+
+stbi_inline static int zhuffman_decode(zbuf *a, zhuffman *z)
+{
+   int b,s,k;
+   if (a->num_bits < 16) fill_bits(a);
+   b = z->fast[a->code_buffer & ZFAST_MASK];
+   if (b < 0xffff) {
+      s = z->size[b];
+      a->code_buffer >>= s;
+      a->num_bits -= s;
+      return z->value[b];
+   }
+
+   // not resolved by fast table, so compute it the slow way
+   // use jpeg approach, which requires MSbits at top
+   k = bit_reverse(a->code_buffer, 16);
+   for (s=ZFAST_BITS+1; ; ++s)
+      if (k < z->maxcode[s])
+         break;
+   if (s == 16) return -1; // invalid code!
+   // code size is s, so:
+   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+   assert(z->size[b] == s);
+   a->code_buffer >>= s;
+   a->num_bits -= s;
+   return z->value[b];
+}
+
+static int expand(zbuf *z, int n)  // need to make room for n bytes
+{
+   char *q;
+   int cur, limit;
+   if (!z->z_expandable) return e("output buffer limit","Corrupt PNG");
+   cur   = (int) (z->zout     - z->zout_start);
+   limit = (int) (z->zout_end - z->zout_start);
+   while (cur + n > limit)
+      limit *= 2;
+   q = (char *) realloc(z->zout_start, limit);
+   if (q == NULL) return e("outofmem", "Out of memory");
+   z->zout_start = q;
+   z->zout       = q + cur;
+   z->zout_end   = q + limit;
+   return 1;
+}
+
+static int length_base[31] = {
+   3,4,5,6,7,8,9,10,11,13,
+   15,17,19,23,27,31,35,43,51,59,
+   67,83,99,115,131,163,195,227,258,0,0 };
+
+static int length_extra[31]= 
+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+
+static int dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+static int dist_extra[32] =
+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+static int parse_huffman_block(zbuf *a)
+{
+   for(;;) {
+      int z = zhuffman_decode(a, &a->z_length);
+      if (z < 256) {
+         if (z < 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes
+         if (a->zout >= a->zout_end) if (!expand(a, 1)) return 0;
+         *a->zout++ = (char) z;
+      } else {
+         uint8 *p;
+         int len,dist;
+         if (z == 256) return 1;
+         z -= 257;
+         len = length_base[z];
+         if (length_extra[z]) len += zreceive(a, length_extra[z]);
+         z = zhuffman_decode(a, &a->z_distance);
+         if (z < 0) return e("bad huffman code","Corrupt PNG");
+         dist = dist_base[z];
+         if (dist_extra[z]) dist += zreceive(a, dist_extra[z]);
+         if (a->zout - a->zout_start < dist) return e("bad dist","Corrupt PNG");
+         if (a->zout + len > a->zout_end) if (!expand(a, len)) return 0;
+         p = (uint8 *) (a->zout - dist);
+         while (len--)
+            *a->zout++ = *p++;
+      }
+   }
+}
+
+static int compute_huffman_codes(zbuf *a)
+{
+   static uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+   zhuffman z_codelength;
+   uint8 lencodes[286+32+137];//padding for maximum single op
+   uint8 codelength_sizes[19];
+   int i,n;
+
+   int hlit  = zreceive(a,5) + 257;
+   int hdist = zreceive(a,5) + 1;
+   int hclen = zreceive(a,4) + 4;
+
+   memset(codelength_sizes, 0, sizeof(codelength_sizes));
+   for (i=0; i < hclen; ++i) {
+      int s = zreceive(a,3);
+      codelength_sizes[length_dezigzag[i]] = (uint8) s;
+   }
+   if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+   n = 0;
+   while (n < hlit + hdist) {
+      int c = zhuffman_decode(a, &z_codelength);
+      assert(c >= 0 && c < 19);
+      if (c < 16)
+         lencodes[n++] = (uint8) c;
+      else if (c == 16) {
+         c = zreceive(a,2)+3;
+         memset(lencodes+n, lencodes[n-1], c);
+         n += c;
+      } else if (c == 17) {
+         c = zreceive(a,3)+3;
+         memset(lencodes+n, 0, c);
+         n += c;
+      } else {
+         assert(c == 18);
+         c = zreceive(a,7)+11;
+         memset(lencodes+n, 0, c);
+         n += c;
+      }
+   }
+   if (n != hlit+hdist) return e("bad codelengths","Corrupt PNG");
+   if (!zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+   if (!zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+   return 1;
+}
+
+static int parse_uncompressed_block(zbuf *a)
+{
+   uint8 header[4];
+   int len,nlen,k;
+   if (a->num_bits & 7)
+      zreceive(a, a->num_bits & 7); // discard
+   // drain the bit-packed data into header
+   k = 0;
+   while (a->num_bits > 0) {
+      header[k++] = (uint8) (a->code_buffer & 255); // wtf this warns?
+      a->code_buffer >>= 8;
+      a->num_bits -= 8;
+   }
+   assert(a->num_bits == 0);
+   // now fill header the normal way
+   while (k < 4)
+      header[k++] = (uint8) zget8(a);
+   len  = header[1] * 256 + header[0];
+   nlen = header[3] * 256 + header[2];
+   if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG");
+   if (a->zbuffer + len > a->zbuffer_end) return e("read past buffer","Corrupt PNG");
+   if (a->zout + len > a->zout_end)
+      if (!expand(a, len)) return 0;
+   memcpy(a->zout, a->zbuffer, len);
+   a->zbuffer += len;
+   a->zout += len;
+   return 1;
+}
+
+static int parse_zlib_header(zbuf *a)
+{
+   int cmf   = zget8(a);
+   int cm    = cmf & 15;
+   /* int cinfo = cmf >> 4; */
+   int flg   = zget8(a);
+   if ((cmf*256+flg) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec
+   if (flg & 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+   if (cm != 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png
+   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+   return 1;
+}
+
+// @TODO: should statically initialize these for optimal thread safety
+static uint8 default_length[288], default_distance[32];
+static void init_defaults(void)
+{
+   int i;   // use <= to match clearly with spec
+   for (i=0; i <= 143; ++i)     default_length[i]   = 8;
+   for (   ; i <= 255; ++i)     default_length[i]   = 9;
+   for (   ; i <= 279; ++i)     default_length[i]   = 7;
+   for (   ; i <= 287; ++i)     default_length[i]   = 8;
+
+   for (i=0; i <=  31; ++i)     default_distance[i] = 5;
+}
+
+int stbi_png_partial; // a quick hack to only allow decoding some of a PNG... I should implement real streaming support instead
+static int parse_zlib(zbuf *a, int parse_header)
+{
+   int final, type;
+   if (parse_header)
+      if (!parse_zlib_header(a)) return 0;
+   a->num_bits = 0;
+   a->code_buffer = 0;
+   do {
+      final = zreceive(a,1);
+      type = zreceive(a,2);
+      if (type == 0) {
+         if (!parse_uncompressed_block(a)) return 0;
+      } else if (type == 3) {
+         return 0;
+      } else {
+         if (type == 1) {
+            // use fixed code lengths
+            if (!default_distance[31]) init_defaults();
+            if (!zbuild_huffman(&a->z_length  , default_length  , 288)) return 0;
+            if (!zbuild_huffman(&a->z_distance, default_distance,  32)) return 0;
+         } else {
+            if (!compute_huffman_codes(a)) return 0;
+         }
+         if (!parse_huffman_block(a)) return 0;
+      }
+      if (stbi_png_partial && a->zout - a->zout_start > 65536)
+         break;
+   } while (!final);
+   return 1;
+}
+
+static int do_zlib(zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
+   a->zout_start = obuf;
+   a->zout       = obuf;
+   a->zout_end   = obuf + olen;
+   a->z_expandable = exp;
+
+   return parse_zlib(a, parse_header);
+}
+
+char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+   zbuf a;
+   char *p = (char *) malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (uint8 *) buffer;
+   a.zbuffer_end = (uint8 *) buffer + len;
+   if (do_zlib(&a, p, initial_size, 1, 1)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      free(a.zout_start);
+      return NULL;
+   }
+}
+
+char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+   zbuf a;
+   char *p = (char *) malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (uint8 *) buffer;
+   a.zbuffer_end = (uint8 *) buffer + len;
+   if (do_zlib(&a, p, initial_size, 1, parse_header)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      free(a.zout_start);
+      return NULL;
+   }
+}
+
+int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+   zbuf a;
+   a.zbuffer = (uint8 *) ibuffer;
+   a.zbuffer_end = (uint8 *) ibuffer + ilen;
+   if (do_zlib(&a, obuffer, olen, 0, 1))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+   zbuf a;
+   char *p = (char *) malloc(16384);
+   if (p == NULL) return NULL;
+   a.zbuffer = (uint8 *) buffer;
+   a.zbuffer_end = (uint8 *) buffer+len;
+   if (do_zlib(&a, p, 16384, 1, 0)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      free(a.zout_start);
+      return NULL;
+   }
+}
+
+int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+   zbuf a;
+   a.zbuffer = (uint8 *) ibuffer;
+   a.zbuffer_end = (uint8 *) ibuffer + ilen;
+   if (do_zlib(&a, obuffer, olen, 0, 0))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
+//    simple implementation
+//      - only 8-bit samples
+//      - no CRC checking
+//      - allocates lots of intermediate memory
+//        - avoids problem of streaming data between subsystems
+//        - avoids explicit window management
+//    performance
+//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+
+typedef struct
+{
+   uint32 length;
+   uint32 type;
+} chunk;
+
+#define PNG_TYPE(a,b,c,d)  (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
+
+static chunk get_chunk_header(stbi *s)
+{
+   chunk c;
+   c.length = get32(s);
+   c.type   = get32(s);
+   return c;
+}
+
+static int check_png_header(stbi *s)
+{
+   static uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 };
+   int i;
+   for (i=0; i < 8; ++i)
+      if (get8u(s) != png_sig[i]) return e("bad png sig","Not a PNG");
+   return 1;
+}
+
+typedef struct
+{
+   stbi *s;
+   uint8 *idata, *expanded, *out;
+} png;
+
+
+enum {
+   F_none=0, F_sub=1, F_up=2, F_avg=3, F_paeth=4,
+   F_avg_first, F_paeth_first
+};
+
+static uint8 first_row_filter[5] =
+{
+   F_none, F_sub, F_none, F_avg_first, F_paeth_first
+};
+
+static int paeth(int a, int b, int c)
+{
+   int p = a + b - c;
+   int pa = abs(p-a);
+   int pb = abs(p-b);
+   int pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return a;
+   if (pb <= pc) return b;
+   return c;
+}
+
+// create the png data from post-deflated data
+static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, uint32 x, uint32 y)
+{
+   stbi *s = a->s;
+   uint32 i,j,stride = x*out_n;
+   int k;
+   int img_n = s->img_n; // copy it into a local for later
+   assert(out_n == s->img_n || out_n == s->img_n+1);
+   if (stbi_png_partial) y = 1;
+   a->out = (uint8 *) malloc(x * y * out_n);
+   if (!a->out) return e("outofmem", "Out of memory");
+   if (!stbi_png_partial) {
+      if (s->img_x == x && s->img_y == y) {
+         if (raw_len != (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
+      } else { // interlaced:
+         if (raw_len < (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
+      }
+   }
+   for (j=0; j < y; ++j) {
+      uint8 *cur = a->out + stride*j;
+      uint8 *prior = cur - stride;
+      int filter = *raw++;
+      if (filter > 4) return e("invalid filter","Corrupt PNG");
+      // if first row, use special filter that doesn't sample previous row
+      if (j == 0) filter = first_row_filter[filter];
+      // handle first pixel explicitly
+      for (k=0; k < img_n; ++k) {
+         switch (filter) {
+            case F_none       : cur[k] = raw[k]; break;
+            case F_sub        : cur[k] = raw[k]; break;
+            case F_up         : cur[k] = raw[k] + prior[k]; break;
+            case F_avg        : cur[k] = raw[k] + (prior[k]>>1); break;
+            case F_paeth      : cur[k] = (uint8) (raw[k] + paeth(0,prior[k],0)); break;
+            case F_avg_first  : cur[k] = raw[k]; break;
+            case F_paeth_first: cur[k] = raw[k]; break;
+         }
+      }
+      if (img_n != out_n) cur[img_n] = 255;
+      raw += img_n;
+      cur += out_n;
+      prior += out_n;
+      // this is a little gross, so that we don't switch per-pixel or per-component
+      if (img_n == out_n) {
+         #define CASE(f) \
+             case f:     \
+                for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \
+                   for (k=0; k < img_n; ++k)
+         switch (filter) {
+            CASE(F_none)  cur[k] = raw[k]; break;
+            CASE(F_sub)   cur[k] = raw[k] + cur[k-img_n]; break;
+            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
+            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break;
+            CASE(F_paeth)  cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break;
+            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-img_n] >> 1); break;
+            CASE(F_paeth_first)  cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break;
+         }
+         #undef CASE
+      } else {
+         assert(img_n+1 == out_n);
+         #define CASE(f) \
+             case f:     \
+                for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
+                   for (k=0; k < img_n; ++k)
+         switch (filter) {
+            CASE(F_none)  cur[k] = raw[k]; break;
+            CASE(F_sub)   cur[k] = raw[k] + cur[k-out_n]; break;
+            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
+            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break;
+            CASE(F_paeth)  cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break;
+            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-out_n] >> 1); break;
+            CASE(F_paeth_first)  cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break;
+         }
+         #undef CASE
+      }
+   }
+   return 1;
+}
+
+static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n, int interlaced)
+{
+   uint8 *final;
+   int p;
+   int save;
+   if (!interlaced)
+      return create_png_image_raw(a, raw, raw_len, out_n, a->s->img_x, a->s->img_y);
+   save = stbi_png_partial;
+   stbi_png_partial = 0;
+
+   // de-interlacing
+   final = (uint8 *) malloc(a->s->img_x * a->s->img_y * out_n);
+   for (p=0; p < 7; ++p) {
+      int xorig[] = { 0,4,0,2,0,1,0 };
+      int yorig[] = { 0,0,4,0,2,0,1 };
+      int xspc[]  = { 8,8,4,4,2,2,1 };
+      int yspc[]  = { 8,8,8,4,4,2,2 };
+      int i,j,x,y;
+      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+      if (x && y) {
+         if (!create_png_image_raw(a, raw, raw_len, out_n, x, y)) {
+            free(final);
+            return 0;
+         }
+         for (j=0; j < y; ++j)
+            for (i=0; i < x; ++i)
+               memcpy(final + (j*yspc[p]+yorig[p])*a->s->img_x*out_n + (i*xspc[p]+xorig[p])*out_n,
+                      a->out + (j*x+i)*out_n, out_n);
+         free(a->out);
+         raw += (x*out_n+1)*y;
+         raw_len -= (x*out_n+1)*y;
+      }
+   }
+   a->out = final;
+
+   stbi_png_partial = save;
+   return 1;
+}
+
+static int compute_transparency(png *z, uint8 tc[3], int out_n)
+{
+   stbi *s = z->s;
+   uint32 i, pixel_count = s->img_x * s->img_y;
+   uint8 *p = z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 255 as the alpha value in the output
+   assert(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i=0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 255);
+         p += 2;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int expand_palette(png *a, uint8 *palette, int len, int pal_img_n)
+{
+   uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+   uint8 *p, *temp_out, *orig = a->out;
+
+   p = (uint8 *) malloc(pixel_count * pal_img_n);
+   if (p == NULL) return e("outofmem", "Out of memory");
+
+   // between here and free(out) below, exitting would leak
+   temp_out = p;
+
+   if (pal_img_n == 3) {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p += 3;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p[3] = palette[n+3];
+         p += 4;
+      }
+   }
+   free(a->out);
+   a->out = temp_out;
+
+   STBI_NOTUSED(len);
+
+   return 1;
+}
+
+static int stbi_unpremultiply_on_load = 0;
+static int stbi_de_iphone_flag = 0;
+
+void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+   stbi_unpremultiply_on_load = flag_true_if_should_unpremultiply;
+}
+void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+   stbi_de_iphone_flag = flag_true_if_should_convert;
+}
+
+static void stbi_de_iphone(png *z)
+{
+   stbi *s = z->s;
+   uint32 i, pixel_count = s->img_x * s->img_y;
+   uint8 *p = z->out;
+
+   if (s->img_out_n == 3) {  // convert bgr to rgb
+      for (i=0; i < pixel_count; ++i) {
+         uint8 t = p[0];
+         p[0] = p[2];
+         p[2] = t;
+         p += 3;
+      }
+   } else {
+      assert(s->img_out_n == 4);
+      if (stbi_unpremultiply_on_load) {
+         // convert bgr to rgb and unpremultiply
+         for (i=0; i < pixel_count; ++i) {
+            uint8 a = p[3];
+            uint8 t = p[0];
+            if (a) {
+               p[0] = p[2] * 255 / a;
+               p[1] = p[1] * 255 / a;
+               p[2] =  t   * 255 / a;
+            } else {
+               p[0] = p[2];
+               p[2] = t;
+            } 
+            p += 4;
+         }
+      } else {
+         // convert bgr to rgb
+         for (i=0; i < pixel_count; ++i) {
+            uint8 t = p[0];
+            p[0] = p[2];
+            p[2] = t;
+            p += 4;
+         }
+      }
+   }
+}
+
+static int parse_png_file(png *z, int scan, int req_comp)
+{
+   uint8 palette[1024], pal_img_n=0;
+   uint8 has_trans=0, tc[3];
+   uint32 ioff=0, idata_limit=0, i, pal_len=0;
+   int first=1,k,interlace=0, iphone=0;
+   stbi *s = z->s;
+
+   z->expanded = NULL;
+   z->idata = NULL;
+   z->out = NULL;
+
+   if (!check_png_header(s)) return 0;
+
+   if (scan == SCAN_type) return 1;
+
+   for (;;) {
+      chunk c = get_chunk_header(s);
+      switch (c.type) {
+         case PNG_TYPE('C','g','B','I'):
+            iphone = stbi_de_iphone_flag;
+            skip(s, c.length);
+            break;
+         case PNG_TYPE('I','H','D','R'): {
+            int depth,color,comp,filter;
+            if (!first) return e("multiple IHDR","Corrupt PNG");
+            first = 0;
+            if (c.length != 13) return e("bad IHDR len","Corrupt PNG");
+            s->img_x = get32(s); if (s->img_x > (1 << 24)) return e("too large","Very large image (corrupt?)");
+            s->img_y = get32(s); if (s->img_y > (1 << 24)) return e("too large","Very large image (corrupt?)");
+            depth = get8(s);  if (depth != 8)        return e("8bit only","PNG not supported: 8-bit only");
+            color = get8(s);  if (color > 6)         return e("bad ctype","Corrupt PNG");
+            if (color == 3) pal_img_n = 3; else if (color & 1) return e("bad ctype","Corrupt PNG");
+            comp  = get8(s);  if (comp) return e("bad comp method","Corrupt PNG");
+            filter= get8(s);  if (filter) return e("bad filter method","Corrupt PNG");
+            interlace = get8(s); if (interlace>1) return e("bad interlace method","Corrupt PNG");
+            if (!s->img_x || !s->img_y) return e("0-pixel image","Corrupt PNG");
+            if (!pal_img_n) {
+               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode");
+               if (scan == SCAN_header) return 1;
+            } else {
+               // if paletted, then pal_n is our final components, and
+               // img_n is # components to decompress/filter.
+               s->img_n = 1;
+               if ((1 << 30) / s->img_x / 4 < s->img_y) return e("too large","Corrupt PNG");
+               // if SCAN_header, have to scan to see if we have a tRNS
+            }
+            break;
+         }
+
+         case PNG_TYPE('P','L','T','E'):  {
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if (c.length > 256*3) return e("invalid PLTE","Corrupt PNG");
+            pal_len = c.length / 3;
+            if (pal_len * 3 != c.length) return e("invalid PLTE","Corrupt PNG");
+            for (i=0; i < pal_len; ++i) {
+               palette[i*4+0] = get8u(s);
+               palette[i*4+1] = get8u(s);
+               palette[i*4+2] = get8u(s);
+               palette[i*4+3] = 255;
+            }
+            break;
+         }
+
+         case PNG_TYPE('t','R','N','S'): {
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if (z->idata) return e("tRNS after IDAT","Corrupt PNG");
+            if (pal_img_n) {
+               if (scan == SCAN_header) { s->img_n = 4; return 1; }
+               if (pal_len == 0) return e("tRNS before PLTE","Corrupt PNG");
+               if (c.length > pal_len) return e("bad tRNS len","Corrupt PNG");
+               pal_img_n = 4;
+               for (i=0; i < c.length; ++i)
+                  palette[i*4+3] = get8u(s);
+            } else {
+               if (!(s->img_n & 1)) return e("tRNS with alpha","Corrupt PNG");
+               if (c.length != (uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG");
+               has_trans = 1;
+               for (k=0; k < s->img_n; ++k)
+                  tc[k] = (uint8) get16(s); // non 8-bit images will be larger
+            }
+            break;
+         }
+
+         case PNG_TYPE('I','D','A','T'): {
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG");
+            if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; }
+            if (ioff + c.length > idata_limit) {
+               uint8 *p;
+               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+               while (ioff + c.length > idata_limit)
+                  idata_limit *= 2;
+               p = (uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory");
+               z->idata = p;
+            }
+            if (!getn(s, z->idata+ioff,c.length)) return e("outofdata","Corrupt PNG");
+            ioff += c.length;
+            break;
+         }
+
+         case PNG_TYPE('I','E','N','D'): {
+            uint32 raw_len;
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if (scan != SCAN_load) return 1;
+            if (z->idata == NULL) return e("no IDAT","Corrupt PNG");
+            z->expanded = (uint8 *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !iphone);
+            if (z->expanded == NULL) return 0; // zlib should set error
+            free(z->idata); z->idata = NULL;
+            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+               s->img_out_n = s->img_n+1;
+            else
+               s->img_out_n = s->img_n;
+            if (!create_png_image(z, z->expanded, raw_len, s->img_out_n, interlace)) return 0;
+            if (has_trans)
+               if (!compute_transparency(z, tc, s->img_out_n)) return 0;
+            if (iphone && s->img_out_n > 2)
+               stbi_de_iphone(z);
+            if (pal_img_n) {
+               // pal_img_n == 3 or 4
+               s->img_n = pal_img_n; // record the actual colors we had
+               s->img_out_n = pal_img_n;
+               if (req_comp >= 3) s->img_out_n = req_comp;
+               if (!expand_palette(z, palette, pal_len, s->img_out_n))
+                  return 0;
+            }
+            free(z->expanded); z->expanded = NULL;
+            return 1;
+         }
+
+         default:
+            // if critical, fail
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if ((c.type & (1 << 29)) == 0) {
+               #ifndef STBI_NO_FAILURE_STRINGS
+               // not threadsafe
+               static char invalid_chunk[] = "XXXX chunk not known";
+               invalid_chunk[0] = (uint8) (c.type >> 24);
+               invalid_chunk[1] = (uint8) (c.type >> 16);
+               invalid_chunk[2] = (uint8) (c.type >>  8);
+               invalid_chunk[3] = (uint8) (c.type >>  0);
+               #endif
+               return e(invalid_chunk, "PNG not supported: unknown chunk type");
+            }
+            skip(s, c.length);
+            break;
+      }
+      // end of chunk, read and skip CRC
+      get32(s);
+   }
+}
+
+static unsigned char *do_png(png *p, int *x, int *y, int *n, int req_comp)
+{
+   unsigned char *result=NULL;
+   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
+   if (parse_png_file(p, SCAN_load, req_comp)) {
+      result = p->out;
+      p->out = NULL;
+      if (req_comp && req_comp != p->s->img_out_n) {
+         result = convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         p->s->img_out_n = req_comp;
+         if (result == NULL) return result;
+      }
+      *x = p->s->img_x;
+      *y = p->s->img_y;
+      if (n) *n = p->s->img_n;
+   }
+   free(p->out);      p->out      = NULL;
+   free(p->expanded); p->expanded = NULL;
+   free(p->idata);    p->idata    = NULL;
+
+   return result;
+}
+
+static unsigned char *stbi_png_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   png p;
+   p.s = s;
+   return do_png(&p, x,y,comp,req_comp);
+}
+
+static int stbi_png_test(stbi *s)
+{
+   int r;
+   r = check_png_header(s);
+   stbi_rewind(s);
+   return r;
+}
+
+static int stbi_png_info_raw(png *p, int *x, int *y, int *comp)
+{
+   if (!parse_png_file(p, SCAN_header, 0)) {
+      stbi_rewind( p->s );
+      return 0;
+   }
+   if (x) *x = p->s->img_x;
+   if (y) *y = p->s->img_y;
+   if (comp) *comp = p->s->img_n;
+   return 1;
+}
+
+static int      stbi_png_info(stbi *s, int *x, int *y, int *comp)
+{
+   png p;
+   p.s = s;
+   return stbi_png_info_raw(&p, x, y, comp);
+}
+
+// Microsoft/Windows BMP image
+
+static int bmp_test(stbi *s)
+{
+   int sz;
+   if (get8(s) != 'B') return 0;
+   if (get8(s) != 'M') return 0;
+   get32le(s); // discard filesize
+   get16le(s); // discard reserved
+   get16le(s); // discard reserved
+   get32le(s); // discard data offset
+   sz = get32le(s);
+   if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1;
+   return 0;
+}
+
+static int stbi_bmp_test(stbi *s)
+{
+   int r = bmp_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int high_bit(unsigned int z)
+{
+   int n=0;
+   if (z == 0) return -1;
+   if (z >= 0x10000) n += 16, z >>= 16;
+   if (z >= 0x00100) n +=  8, z >>=  8;
+   if (z >= 0x00010) n +=  4, z >>=  4;
+   if (z >= 0x00004) n +=  2, z >>=  2;
+   if (z >= 0x00002) n +=  1, z >>=  1;
+   return n;
+}
+
+static int bitcount(unsigned int a)
+{
+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
+   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+   a = (a + (a >> 8)); // max 16 per 8 bits
+   a = (a + (a >> 16)); // max 32 per 8 bits
+   return a & 0xff;
+}
+
+static int shiftsigned(int v, int shift, int bits)
+{
+   int result;
+   int z=0;
+
+   if (shift < 0) v <<= -shift;
+   else v >>= shift;
+   result = v;
+
+   z = bits;
+   while (z < 8) {
+      result += v >> z;
+      z += bits;
+   }
+   return result;
+}
+
+static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   uint8 *out;
+   unsigned int mr=0,mg=0,mb=0,ma=0, fake_a=0;
+   stbi_uc pal[256][4];
+   int psize=0,i,j,compress=0,width;
+   int bpp, flip_vertically, pad, target, offset, hsz;
+   if (get8(s) != 'B' || get8(s) != 'M') return epuc("not BMP", "Corrupt BMP");
+   get32le(s); // discard filesize
+   get16le(s); // discard reserved
+   get16le(s); // discard reserved
+   offset = get32le(s);
+   hsz = get32le(s);
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) return epuc("unknown BMP", "BMP type not supported: unknown");
+   if (hsz == 12) {
+      s->img_x = get16le(s);
+      s->img_y = get16le(s);
+   } else {
+      s->img_x = get32le(s);
+      s->img_y = get32le(s);
+   }
+   if (get16le(s) != 1) return epuc("bad BMP", "bad BMP");
+   bpp = get16le(s);
+   if (bpp == 1) return epuc("monochrome", "BMP type not supported: 1-bit");
+   flip_vertically = ((int) s->img_y) > 0;
+   s->img_y = abs((int) s->img_y);
+   if (hsz == 12) {
+      if (bpp < 24)
+         psize = (offset - 14 - 24) / 3;
+   } else {
+      compress = get32le(s);
+      if (compress == 1 || compress == 2) return epuc("BMP RLE", "BMP type not supported: RLE");
+      get32le(s); // discard sizeof
+      get32le(s); // discard hres
+      get32le(s); // discard vres
+      get32le(s); // discard colorsused
+      get32le(s); // discard max important
+      if (hsz == 40 || hsz == 56) {
+         if (hsz == 56) {
+            get32le(s);
+            get32le(s);
+            get32le(s);
+            get32le(s);
+         }
+         if (bpp == 16 || bpp == 32) {
+            mr = mg = mb = 0;
+            if (compress == 0) {
+               if (bpp == 32) {
+                  mr = 0xffu << 16;
+                  mg = 0xffu <<  8;
+                  mb = 0xffu <<  0;
+                  ma = 0xffu << 24;
+                  fake_a = 1; // @TODO: check for cases like alpha value is all 0 and switch it to 255
+               } else {
+                  mr = 31u << 10;
+                  mg = 31u <<  5;
+                  mb = 31u <<  0;
+               }
+            } else if (compress == 3) {
+               mr = get32le(s);
+               mg = get32le(s);
+               mb = get32le(s);
+               // not documented, but generated by photoshop and handled by mspaint
+               if (mr == mg && mg == mb) {
+                  // ?!?!?
+                  return epuc("bad BMP", "bad BMP");
+               }
+            } else
+               return epuc("bad BMP", "bad BMP");
+         }
+      } else {
+         assert(hsz == 108);
+         mr = get32le(s);
+         mg = get32le(s);
+         mb = get32le(s);
+         ma = get32le(s);
+         get32le(s); // discard color space
+         for (i=0; i < 12; ++i)
+            get32le(s); // discard color space parameters
+      }
+      if (bpp < 16)
+         psize = (offset - 14 - hsz) >> 2;
+   }
+   s->img_n = ma ? 4 : 3;
+   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+      target = req_comp;
+   else
+      target = s->img_n; // if they want monochrome, we'll post-convert
+   out = (stbi_uc *) malloc(target * s->img_x * s->img_y);
+   if (!out) return epuc("outofmem", "Out of memory");
+   if (bpp < 16) {
+      int z=0;
+      if (psize == 0 || psize > 256) { free(out); return epuc("invalid", "Corrupt BMP"); }
+      for (i=0; i < psize; ++i) {
+         pal[i][2] = get8u(s);
+         pal[i][1] = get8u(s);
+         pal[i][0] = get8u(s);
+         if (hsz != 12) get8(s);
+         pal[i][3] = 255;
+      }
+      skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
+      if (bpp == 4) width = (s->img_x + 1) >> 1;
+      else if (bpp == 8) width = s->img_x;
+      else { free(out); return epuc("bad bpp", "Corrupt BMP"); }
+      pad = (-width)&3;
+      for (j=0; j < (int) s->img_y; ++j) {
+         for (i=0; i < (int) s->img_x; i += 2) {
+            int v=get8(s),v2=0;
+            if (bpp == 4) {
+               v2 = v & 15;
+               v >>= 4;
+            }
+            out[z++] = pal[v][0];
+            out[z++] = pal[v][1];
+            out[z++] = pal[v][2];
+            if (target == 4) out[z++] = 255;
+            if (i+1 == (int) s->img_x) break;
+            v = (bpp == 8) ? get8(s) : v2;
+            out[z++] = pal[v][0];
+            out[z++] = pal[v][1];
+            out[z++] = pal[v][2];
+            if (target == 4) out[z++] = 255;
+         }
+         skip(s, pad);
+      }
+   } else {
+      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+      int z = 0;
+      int easy=0;
+      skip(s, offset - 14 - hsz);
+      if (bpp == 24) width = 3 * s->img_x;
+      else if (bpp == 16) width = 2*s->img_x;
+      else /* bpp = 32 and pad = 0 */ width=0;
+      pad = (-width) & 3;
+      if (bpp == 24) {
+         easy = 1;
+      } else if (bpp == 32) {
+         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+            easy = 2;
+      }
+      if (!easy) {
+         if (!mr || !mg || !mb) { free(out); return epuc("bad masks", "Corrupt BMP"); }
+         // right shift amt to put high bit in position #7
+         rshift = high_bit(mr)-7; rcount = bitcount(mr);
+         gshift = high_bit(mg)-7; gcount = bitcount(mr);
+         bshift = high_bit(mb)-7; bcount = bitcount(mr);
+         ashift = high_bit(ma)-7; acount = bitcount(mr);
+      }
+      for (j=0; j < (int) s->img_y; ++j) {
+         if (easy) {
+            for (i=0; i < (int) s->img_x; ++i) {
+               int a;
+               out[z+2] = get8u(s);
+               out[z+1] = get8u(s);
+               out[z+0] = get8u(s);
+               z += 3;
+               a = (easy == 2 ? get8(s) : 255);
+               if (target == 4) out[z++] = (uint8) a;
+            }
+         } else {
+            for (i=0; i < (int) s->img_x; ++i) {
+               uint32 v = (bpp == 16 ? get16le(s) : get32le(s));
+               int a;
+               out[z++] = (uint8) shiftsigned(v & mr, rshift, rcount);
+               out[z++] = (uint8) shiftsigned(v & mg, gshift, gcount);
+               out[z++] = (uint8) shiftsigned(v & mb, bshift, bcount);
+               a = (ma ? shiftsigned(v & ma, ashift, acount) : 255);
+               if (target == 4) out[z++] = (uint8) a; 
+            }
+         }
+         skip(s, pad);
+      }
+   }
+   if (flip_vertically) {
+      stbi_uc t;
+      for (j=0; j < (int) s->img_y>>1; ++j) {
+         stbi_uc *p1 = out +      j     *s->img_x*target;
+         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+         for (i=0; i < (int) s->img_x*target; ++i) {
+            t = p1[i], p1[i] = p2[i], p2[i] = t;
+         }
+      }
+   }
+
+   if (req_comp && req_comp != target) {
+      out = convert_format(out, target, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // convert_format frees input on failure
+   }
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+   return out;
+}
+
+static stbi_uc *stbi_bmp_load(stbi *s,int *x, int *y, int *comp, int req_comp)
+{
+   return bmp_load(s, x,y,comp,req_comp);
+}
+
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+
+static int tga_info(stbi *s, int *x, int *y, int *comp)
+{
+    int tga_w, tga_h, tga_comp;
+    int sz;
+    get8u(s);                   // discard Offset
+    sz = get8u(s);              // color type
+    if( sz > 1 ) {
+        stbi_rewind(s);
+        return 0;      // only RGB or indexed allowed
+    }
+    sz = get8u(s);              // image type
+    // only RGB or grey allowed, +/- RLE
+    if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0;
+    skip(s,9);
+    tga_w = get16le(s);
+    if( tga_w < 1 ) {
+        stbi_rewind(s);
+        return 0;   // test width
+    }
+    tga_h = get16le(s);
+    if( tga_h < 1 ) {
+        stbi_rewind(s);
+        return 0;   // test height
+    }
+    sz = get8(s);               // bits per pixel
+    // only RGB or RGBA or grey allowed
+    if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) {
+        stbi_rewind(s);
+        return 0;
+    }
+    tga_comp = sz;
+    if (x) *x = tga_w;
+    if (y) *y = tga_h;
+    if (comp) *comp = tga_comp / 8;
+    return 1;                   // seems to have passed everything
+}
+
+int stbi_tga_info(stbi *s, int *x, int *y, int *comp)
+{
+    return tga_info(s, x, y, comp);
+}
+
+static int tga_test(stbi *s)
+{
+   int sz;
+   get8u(s);      //   discard Offset
+   sz = get8u(s);   //   color type
+   if ( sz > 1 ) return 0;   //   only RGB or indexed allowed
+   sz = get8u(s);   //   image type
+   if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0;   //   only RGB or grey allowed, +/- RLE
+   get16(s);      //   discard palette start
+   get16(s);      //   discard palette length
+   get8(s);         //   discard bits per palette color entry
+   get16(s);      //   discard x origin
+   get16(s);      //   discard y origin
+   if ( get16(s) < 1 ) return 0;      //   test width
+   if ( get16(s) < 1 ) return 0;      //   test height
+   sz = get8(s);   //   bits per pixel
+   if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) return 0;   //   only RGB or RGBA or grey allowed
+   return 1;      //   seems to have passed everything
+}
+
+static int stbi_tga_test(stbi *s)
+{
+   int res = tga_test(s);
+   stbi_rewind(s);
+   return res;
+}
+
+static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   //   read in the TGA header stuff
+   int tga_offset = get8u(s);
+   int tga_indexed = get8u(s);
+   int tga_image_type = get8u(s);
+   int tga_is_RLE = 0;
+   int tga_palette_start = get16le(s);
+   int tga_palette_len = get16le(s);
+   int tga_palette_bits = get8u(s);
+   int tga_x_origin = get16le(s);
+   int tga_y_origin = get16le(s);
+   int tga_width = get16le(s);
+   int tga_height = get16le(s);
+   int tga_bits_per_pixel = get8u(s);
+   int tga_inverted = get8u(s);
+   //   image data
+   unsigned char *tga_data;
+   unsigned char *tga_palette = NULL;
+   int i, j;
+   unsigned char raw_data[4];
+   unsigned char trans_data[4];
+   int RLE_count = 0;
+   int RLE_repeating = 0;
+   int read_next_pixel = 1;
+
+   //   do a tiny bit of precessing
+   if ( tga_image_type >= 8 )
+   {
+      tga_image_type -= 8;
+      tga_is_RLE = 1;
+   }
+   /* int tga_alpha_bits = tga_inverted & 15; */
+   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+   //   error check
+   if ( //(tga_indexed) ||
+      (tga_width < 1) || (tga_height < 1) ||
+      (tga_image_type < 1) || (tga_image_type > 3) ||
+      ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
+      (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
+      )
+   {
+      return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA
+   }
+
+   //   If I'm paletted, then I'll use the number of bits from the palette
+   if ( tga_indexed )
+   {
+      tga_bits_per_pixel = tga_palette_bits;
+   }
+
+   //   tga info
+   *x = tga_width;
+   *y = tga_height;
+   if ( (req_comp < 1) || (req_comp > 4) )
+   {
+      //   just use whatever the file was
+      req_comp = tga_bits_per_pixel / 8;
+      *comp = req_comp;
+   } else
+   {
+      //   force a new number of components
+      *comp = tga_bits_per_pixel/8;
+   }
+   tga_data = (unsigned char*)malloc( tga_width * tga_height * req_comp );
+   if (!tga_data) return epuc("outofmem", "Out of memory");
+
+   //   skip to the data's starting position (offset usually = 0)
+   skip(s, tga_offset );
+   //   do I need to load a palette?
+   if ( tga_indexed )
+   {
+      //   any data to skip? (offset usually = 0)
+      skip(s, tga_palette_start );
+      //   load the palette
+      tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 );
+      if (!tga_palette) return epuc("outofmem", "Out of memory");
+      if (!getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) {
+         free(tga_data);
+         free(tga_palette);
+         return epuc("bad palette", "Corrupt TGA");
+      }
+   }
+   //   load the data
+   trans_data[0] = trans_data[1] = trans_data[2] = trans_data[3] = 0;
+   for (i=0; i < tga_width * tga_height; ++i)
+   {
+      //   if I'm in RLE mode, do I need to get a RLE chunk?
+      if ( tga_is_RLE )
+      {
+         if ( RLE_count == 0 )
+         {
+            //   yep, get the next byte as a RLE command
+            int RLE_cmd = get8u(s);
+            RLE_count = 1 + (RLE_cmd & 127);
+            RLE_repeating = RLE_cmd >> 7;
+            read_next_pixel = 1;
+         } else if ( !RLE_repeating )
+         {
+            read_next_pixel = 1;
+         }
+      } else
+      {
+         read_next_pixel = 1;
+      }
+      //   OK, if I need to read a pixel, do it now
+      if ( read_next_pixel )
+      {
+         //   load however much data we did have
+         if ( tga_indexed )
+         {
+            //   read in 1 byte, then perform the lookup
+            int pal_idx = get8u(s);
+            if ( pal_idx >= tga_palette_len )
+            {
+               //   invalid index
+               pal_idx = 0;
+            }
+            pal_idx *= tga_bits_per_pixel / 8;
+            for (j = 0; j*8 < tga_bits_per_pixel; ++j)
+            {
+               raw_data[j] = tga_palette[pal_idx+j];
+            }
+         } else
+         {
+            //   read in the data raw
+            for (j = 0; j*8 < tga_bits_per_pixel; ++j)
+            {
+               raw_data[j] = get8u(s);
+            }
+         }
+         //   convert raw to the intermediate format
+         switch (tga_bits_per_pixel)
+         {
+         case 8:
+            //   Luminous => RGBA
+            trans_data[0] = raw_data[0];
+            trans_data[1] = raw_data[0];
+            trans_data[2] = raw_data[0];
+            trans_data[3] = 255;
+            break;
+         case 16:
+            //   Luminous,Alpha => RGBA
+            trans_data[0] = raw_data[0];
+            trans_data[1] = raw_data[0];
+            trans_data[2] = raw_data[0];
+            trans_data[3] = raw_data[1];
+            break;
+         case 24:
+            //   BGR => RGBA
+            trans_data[0] = raw_data[2];
+            trans_data[1] = raw_data[1];
+            trans_data[2] = raw_data[0];
+            trans_data[3] = 255;
+            break;
+         case 32:
+            //   BGRA => RGBA
+            trans_data[0] = raw_data[2];
+            trans_data[1] = raw_data[1];
+            trans_data[2] = raw_data[0];
+            trans_data[3] = raw_data[3];
+            break;
+         }
+         //   clear the reading flag for the next pixel
+         read_next_pixel = 0;
+      } // end of reading a pixel
+      //   convert to final format
+      switch (req_comp)
+      {
+      case 1:
+         //   RGBA => Luminance
+         tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
+         break;
+      case 2:
+         //   RGBA => Luminance,Alpha
+         tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
+         tga_data[i*req_comp+1] = trans_data[3];
+         break;
+      case 3:
+         //   RGBA => RGB
+         tga_data[i*req_comp+0] = trans_data[0];
+         tga_data[i*req_comp+1] = trans_data[1];
+         tga_data[i*req_comp+2] = trans_data[2];
+         break;
+      case 4:
+         //   RGBA => RGBA
+         tga_data[i*req_comp+0] = trans_data[0];
+         tga_data[i*req_comp+1] = trans_data[1];
+         tga_data[i*req_comp+2] = trans_data[2];
+         tga_data[i*req_comp+3] = trans_data[3];
+         break;
+      }
+      //   in case we're in RLE mode, keep counting down
+      --RLE_count;
+   }
+   //   do I need to invert the image?
+   if ( tga_inverted )
+   {
+      for (j = 0; j*2 < tga_height; ++j)
+      {
+         int index1 = j * tga_width * req_comp;
+         int index2 = (tga_height - 1 - j) * tga_width * req_comp;
+         for (i = tga_width * req_comp; i > 0; --i)
+         {
+            unsigned char temp = tga_data[index1];
+            tga_data[index1] = tga_data[index2];
+            tga_data[index2] = temp;
+            ++index1;
+            ++index2;
+         }
+      }
+   }
+   //   clear my palette, if I had one
+   if ( tga_palette != NULL )
+   {
+      free( tga_palette );
+   }
+   //   the things I do to get rid of an error message, and yet keep
+   //   Microsoft's C compilers happy... [8^(
+   tga_palette_start = tga_palette_len = tga_palette_bits =
+         tga_x_origin = tga_y_origin = 0;
+   //   OK, done
+   return tga_data;
+}
+
+static stbi_uc *stbi_tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   return tga_load(s,x,y,comp,req_comp);
+}
+
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+static int psd_test(stbi *s)
+{
+   if (get32(s) != 0x38425053) return 0;   // "8BPS"
+   else return 1;
+}
+
+static int stbi_psd_test(stbi *s)
+{
+   int r = psd_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   int   pixelCount;
+   int channelCount, compression;
+   int channel, i, count, len;
+   int w,h;
+   uint8 *out;
+
+   // Check identifier
+   if (get32(s) != 0x38425053)   // "8BPS"
+      return epuc("not PSD", "Corrupt PSD image");
+
+   // Check file type version.
+   if (get16(s) != 1)
+      return epuc("wrong version", "Unsupported version of PSD image");
+
+   // Skip 6 reserved bytes.
+   skip(s, 6 );
+
+   // Read the number of channels (R, G, B, A, etc).
+   channelCount = get16(s);
+   if (channelCount < 0 || channelCount > 16)
+      return epuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+   // Read the rows and columns of the image.
+   h = get32(s);
+   w = get32(s);
+   
+   // Make sure the depth is 8 bits.
+   if (get16(s) != 8)
+      return epuc("unsupported bit depth", "PSD bit depth is not 8 bit");
+
+   // Make sure the color mode is RGB.
+   // Valid options are:
+   //   0: Bitmap
+   //   1: Grayscale
+   //   2: Indexed color
+   //   3: RGB color
+   //   4: CMYK color
+   //   7: Multichannel
+   //   8: Duotone
+   //   9: Lab color
+   if (get16(s) != 3)
+      return epuc("wrong color format", "PSD is not in RGB color format");
+
+   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
+   skip(s,get32(s) );
+
+   // Skip the image resources.  (resolution, pen tool paths, etc)
+   skip(s, get32(s) );
+
+   // Skip the reserved data.
+   skip(s, get32(s) );
+
+   // Find out if the data is compressed.
+   // Known values:
+   //   0: no compression
+   //   1: RLE compressed
+   compression = get16(s);
+   if (compression > 1)
+      return epuc("bad compression", "PSD has an unknown compression format");
+
+   // Create the destination image.
+   out = (stbi_uc *) malloc(4 * w*h);
+   if (!out) return epuc("outofmem", "Out of memory");
+   pixelCount = w*h;
+
+   // Initialize the data to zero.
+   //memset( out, 0, pixelCount * 4 );
+   
+   // Finally, the image data.
+   if (compression) {
+      // RLE as used by .PSD and .TIFF
+      // Loop until you get the number of unpacked bytes you are expecting:
+      //     Read the next source byte into n.
+      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+      //     Else if n is 128, noop.
+      // Endloop
+
+      // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
+      // which we're going to just skip.
+      skip(s, h * channelCount * 2 );
+
+      // Read the RLE data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         uint8 *p;
+         
+         p = out+channel;
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4;
+         } else {
+            // Read the RLE data.
+            count = 0;
+            while (count < pixelCount) {
+               len = get8(s);
+               if (len == 128) {
+                  // No-op.
+               } else if (len < 128) {
+                  // Copy next len+1 bytes literally.
+                  len++;
+                  count += len;
+                  while (len) {
+                     *p = get8u(s);
+                     p += 4;
+                     len--;
+                  }
+               } else if (len > 128) {
+                  uint8   val;
+                  // Next -len+1 bytes in the dest are replicated from next source byte.
+                  // (Interpret len as a negative 8-bit int.)
+                  len ^= 0x0FF;
+                  len += 2;
+                  val = get8u(s);
+                  count += len;
+                  while (len) {
+                     *p = val;
+                     p += 4;
+                     len--;
+                  }
+               }
+            }
+         }
+      }
+      
+   } else {
+      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
+      // where each channel consists of an 8-bit value for each pixel in the image.
+      
+      // Read the data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         uint8 *p;
+         
+         p = out + channel;
+         if (channel > channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4;
+         } else {
+            // Read the data.
+            for (i = 0; i < pixelCount; i++)
+               *p = get8u(s), p += 4;
+         }
+      }
+   }
+
+   if (req_comp && req_comp != 4) {
+      out = convert_format(out, 4, req_comp, w, h);
+      if (out == NULL) return out; // convert_format frees input on failure
+   }
+
+   if (comp) *comp = channelCount;
+   *y = h;
+   *x = w;
+   
+   return out;
+}
+
+static stbi_uc *stbi_psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   return psd_load(s,x,y,comp,req_comp);
+}
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+static int pic_is4(stbi *s,const char *str)
+{
+   int i;
+   for (i=0; i<4; ++i)
+      if (get8(s) != (stbi_uc)str[i])
+         return 0;
+
+   return 1;
+}
+
+static int pic_test(stbi *s)
+{
+   int i;
+
+   if (!pic_is4(s,"\x53\x80\xF6\x34"))
+      return 0;
+
+   for(i=0;i<84;++i)
+      get8(s);
+
+   if (!pic_is4(s,"PICT"))
+      return 0;
+
+   return 1;
+}
+
+typedef struct
+{
+   stbi_uc size,type,channel;
+} pic_packet_t;
+
+static stbi_uc *pic_readval(stbi *s, int channel, stbi_uc *dest)
+{
+   int mask=0x80, i;
+
+   for (i=0; i<4; ++i, mask>>=1) {
+      if (channel & mask) {
+         if (at_eof(s)) return epuc("bad file","PIC file too short");
+         dest[i]=get8u(s);
+      }
+   }
+
+   return dest;
+}
+
+static void pic_copyval(int channel,stbi_uc *dest,const stbi_uc *src)
+{
+   int mask=0x80,i;
+
+   for (i=0;i<4; ++i, mask>>=1)
+      if (channel&mask)
+         dest[i]=src[i];
+}
+
+static stbi_uc *pic_load2(stbi *s,int width,int height,int *comp, stbi_uc *result)
+{
+   int act_comp=0,num_packets=0,y,chained;
+   pic_packet_t packets[10];
+
+   // this will (should...) cater for even some bizarre stuff like having data
+    // for the same channel in multiple packets.
+   do {
+      pic_packet_t *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return epuc("bad format","too many packets");
+
+      packet = &packets[num_packets++];
+
+      chained = get8(s);
+      packet->size    = get8u(s);
+      packet->type    = get8u(s);
+      packet->channel = get8u(s);
+
+      act_comp |= packet->channel;
+
+      if (at_eof(s))          return epuc("bad file","file too short (reading packets)");
+      if (packet->size != 8)  return epuc("bad format","packet isn't 8bpp");
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+
+   for(y=0; y<height; ++y) {
+      int packet_idx;
+
+      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+         pic_packet_t *packet = &packets[packet_idx];
+         stbi_uc *dest = result+y*width*4;
+
+         switch (packet->type) {
+            default:
+               return epuc("bad format","packet has bad compression type");
+
+            case 0: {//uncompressed
+               int x;
+
+               for(x=0;x<width;++x, dest+=4)
+                  if (!pic_readval(s,packet->channel,dest))
+                     return 0;
+               break;
+            }
+
+            case 1://Pure RLE
+               {
+                  int left=width, i;
+
+                  while (left>0) {
+                     stbi_uc count,value[4];
+
+                     count=get8u(s);
+                     if (at_eof(s))   return epuc("bad file","file too short (pure read count)");
+
+                     if (count > left)
+                        count = (uint8) left;
+
+                     if (!pic_readval(s,packet->channel,value))  return 0;
+
+                     for(i=0; i<count; ++i,dest+=4)
+                        pic_copyval(packet->channel,dest,value);
+                     left -= count;
+                  }
+               }
+               break;
+
+            case 2: {//Mixed RLE
+               int left=width;
+               while (left>0) {
+                  int count = get8(s), i;
+                  if (at_eof(s))  return epuc("bad file","file too short (mixed read count)");
+
+                  if (count >= 128) { // Repeated
+                     stbi_uc value[4];
+                     int i;
+
+                     if (count==128)
+                        count = get16(s);
+                     else
+                        count -= 127;
+                     if (count > left)
+                        return epuc("bad file","scanline overrun");
+
+                     if (!pic_readval(s,packet->channel,value))
+                        return 0;
+
+                     for(i=0;i<count;++i, dest += 4)
+                        pic_copyval(packet->channel,dest,value);
+                  } else { // Raw
+                     ++count;
+                     if (count>left) return epuc("bad file","scanline overrun");
+
+                     for(i=0;i<count;++i, dest+=4)
+                        if (!pic_readval(s,packet->channel,dest))
+                           return 0;
+                  }
+                  left-=count;
+               }
+               break;
+            }
+         }
+      }
+   }
+
+   return result;
+}
+
+static stbi_uc *pic_load(stbi *s,int *px,int *py,int *comp,int req_comp)
+{
+   stbi_uc *result;
+   int i, x,y;
+
+   for (i=0; i<92; ++i)
+      get8(s);
+
+   x = get16(s);
+   y = get16(s);
+   if (at_eof(s))  return epuc("bad file","file too short (pic header)");
+   if ((1 << 28) / x < y) return epuc("too large", "Image too large to decode");
+
+   get32(s); //skip `ratio'
+   get16(s); //skip `fields'
+   get16(s); //skip `pad'
+
+   // intermediate buffer is RGBA
+   result = (stbi_uc *) malloc(x*y*4);
+   memset(result, 0xff, x*y*4);
+
+   if (!pic_load2(s,x,y,comp, result)) {
+      free(result);
+      result=0;
+   }
+   *px = x;
+   *py = y;
+   if (req_comp == 0) req_comp = *comp;
+   result=convert_format(result,4,req_comp,x,y);
+
+   return result;
+}
+
+static int stbi_pic_test(stbi *s)
+{
+   int r = pic_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   return pic_load(s,x,y,comp,req_comp);
+}
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+typedef struct stbi_gif_lzw_struct {
+   int16 prefix;
+   uint8 first;
+   uint8 suffix;
+} stbi_gif_lzw;
+
+typedef struct stbi_gif_struct
+{
+   int w,h;
+   stbi_uc *out;                 // output buffer (always 4 components)
+   int flags, bgindex, ratio, transparent, eflags;
+   uint8  pal[256][4];
+   uint8 lpal[256][4];
+   stbi_gif_lzw codes[4096];
+   uint8 *color_table;
+   int parse, step;
+   int lflags;
+   int start_x, start_y;
+   int max_x, max_y;
+   int cur_x, cur_y;
+   int line_size;
+} stbi_gif;
+
+static int gif_test(stbi *s)
+{
+   int sz;
+   if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') return 0;
+   sz = get8(s);
+   if (sz != '9' && sz != '7') return 0;
+   if (get8(s) != 'a') return 0;
+   return 1;
+}
+
+static int stbi_gif_test(stbi *s)
+{
+   int r = gif_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+static void stbi_gif_parse_colortable(stbi *s, uint8 pal[256][4], int num_entries, int transp)
+{
+   int i;
+   for (i=0; i < num_entries; ++i) {
+      pal[i][2] = get8u(s);
+      pal[i][1] = get8u(s);
+      pal[i][0] = get8u(s);
+      pal[i][3] = transp ? 0 : 255;
+   }   
+}
+
+static int stbi_gif_header(stbi *s, stbi_gif *g, int *comp, int is_info)
+{
+   uint8 version;
+   if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8')
+      return e("not GIF", "Corrupt GIF");
+
+   version = get8u(s);
+   if (version != '7' && version != '9')    return e("not GIF", "Corrupt GIF");
+   if (get8(s) != 'a')                      return e("not GIF", "Corrupt GIF");
+ 
+   failure_reason = "";
+   g->w = get16le(s);
+   g->h = get16le(s);
+   g->flags = get8(s);
+   g->bgindex = get8(s);
+   g->ratio = get8(s);
+   g->transparent = -1;
+
+   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
+
+   if (is_info) return 1;
+
+   if (g->flags & 0x80)
+      stbi_gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+   return 1;
+}
+
+static int stbi_gif_info_raw(stbi *s, int *x, int *y, int *comp)
+{
+   stbi_gif g;   
+   if (!stbi_gif_header(s, &g, comp, 1)) {
+      stbi_rewind( s );
+      return 0;
+   }
+   if (x) *x = g.w;
+   if (y) *y = g.h;
+   return 1;
+}
+
+static void stbi_out_gif_code(stbi_gif *g, uint16 code)
+{
+   uint8 *p, *c;
+
+   // recurse to decode the prefixes, since the linked-list is backwards,
+   // and working backwards through an interleaved image would be nasty
+   if (g->codes[code].prefix >= 0)
+      stbi_out_gif_code(g, g->codes[code].prefix);
+
+   if (g->cur_y >= g->max_y) return;
+  
+   p = &g->out[g->cur_x + g->cur_y];
+   c = &g->color_table[g->codes[code].suffix * 4];
+
+   if (c[3] >= 128) {
+      p[0] = c[2];
+      p[1] = c[1];
+      p[2] = c[0];
+      p[3] = c[3];
+   }
+   g->cur_x += 4;
+
+   if (g->cur_x >= g->max_x) {
+      g->cur_x = g->start_x;
+      g->cur_y += g->step;
+
+      while (g->cur_y >= g->max_y && g->parse > 0) {
+         g->step = (1 << g->parse) * g->line_size;
+         g->cur_y = g->start_y + (g->step >> 1);
+         --g->parse;
+      }
+   }
+}
+
+static uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g)
+{
+   uint8 lzw_cs;
+   int32 len, code;
+   uint32 first;
+   int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+   stbi_gif_lzw *p;
+
+   lzw_cs = get8u(s);
+   clear = 1 << lzw_cs;
+   first = 1;
+   codesize = lzw_cs + 1;
+   codemask = (1 << codesize) - 1;
+   bits = 0;
+   valid_bits = 0;
+   for (code = 0; code < clear; code++) {
+      g->codes[code].prefix = -1;
+      g->codes[code].first = (uint8) code;
+      g->codes[code].suffix = (uint8) code;
+   }
+
+   // support no starting clear code
+   avail = clear+2;
+   oldcode = -1;
+
+   len = 0;
+   for(;;) {
+      if (valid_bits < codesize) {
+         if (len == 0) {
+            len = get8(s); // start new block
+            if (len == 0) 
+               return g->out;
+         }
+         --len;
+         bits |= (int32) get8(s) << valid_bits;
+         valid_bits += 8;
+      } else {
+         int32 code = bits & codemask;
+         bits >>= codesize;
+         valid_bits -= codesize;
+         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+         if (code == clear) {  // clear code
+            codesize = lzw_cs + 1;
+            codemask = (1 << codesize) - 1;
+            avail = clear + 2;
+            oldcode = -1;
+            first = 0;
+         } else if (code == clear + 1) { // end of stream code
+            skip(s, len);
+            while ((len = get8(s)) > 0)
+               skip(s,len);
+            return g->out;
+         } else if (code <= avail) {
+            if (first) return epuc("no clear code", "Corrupt GIF");
+
+            if (oldcode >= 0) {
+               p = &g->codes[avail++];
+               if (avail > 4096)        return epuc("too many codes", "Corrupt GIF");
+               p->prefix = (int16) oldcode;
+               p->first = g->codes[oldcode].first;
+               p->suffix = (code == avail) ? p->first : g->codes[code].first;
+            } else if (code == avail)
+               return epuc("illegal code in raster", "Corrupt GIF");
+
+            stbi_out_gif_code(g, (uint16) code);
+
+            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+               codesize++;
+               codemask = (1 << codesize) - 1;
+            }
+
+            oldcode = code;
+         } else {
+            return epuc("illegal code in raster", "Corrupt GIF");
+         }
+      } 
+   }
+}
+
+static void stbi_fill_gif_background(stbi_gif *g)
+{
+   int i;
+   uint8 *c = g->pal[g->bgindex];
+   // @OPTIMIZE: write a dword at a time
+   for (i = 0; i < g->w * g->h * 4; i += 4) {
+      uint8 *p  = &g->out[i];
+      p[0] = c[2];
+      p[1] = c[1];
+      p[2] = c[0];
+      p[3] = c[3];
+   }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+static uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp)
+{
+   int i;
+   uint8 *old_out = 0;
+
+   if (g->out == 0) {
+      if (!stbi_gif_header(s, g, comp,0))     return 0; // failure_reason set by stbi_gif_header
+      g->out = (uint8 *) malloc(4 * g->w * g->h);
+      if (g->out == 0)                      return epuc("outofmem", "Out of memory");
+      stbi_fill_gif_background(g);
+   } else {
+      // animated-gif-only path
+      if (((g->eflags & 0x1C) >> 2) == 3) {
+         old_out = g->out;
+         g->out = (uint8 *) malloc(4 * g->w * g->h);
+         if (g->out == 0)                   return epuc("outofmem", "Out of memory");
+         memcpy(g->out, old_out, g->w*g->h*4);
+      }
+   }
+    
+   for (;;) {
+      switch (get8(s)) {
+         case 0x2C: /* Image Descriptor */
+         {
+            int32 x, y, w, h;
+            uint8 *o;
+
+            x = get16le(s);
+            y = get16le(s);
+            w = get16le(s);
+            h = get16le(s);
+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+               return epuc("bad Image Descriptor", "Corrupt GIF");
+
+            g->line_size = g->w * 4;
+            g->start_x = x * 4;
+            g->start_y = y * g->line_size;
+            g->max_x   = g->start_x + w * 4;
+            g->max_y   = g->start_y + h * g->line_size;
+            g->cur_x   = g->start_x;
+            g->cur_y   = g->start_y;
+
+            g->lflags = get8(s);
+
+            if (g->lflags & 0x40) {
+               g->step = 8 * g->line_size; // first interlaced spacing
+               g->parse = 3;
+            } else {
+               g->step = g->line_size;
+               g->parse = 0;
+            }
+
+            if (g->lflags & 0x80) {
+               stbi_gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+               g->color_table = (uint8 *) g->lpal;       
+            } else if (g->flags & 0x80) {
+               for (i=0; i < 256; ++i)  // @OPTIMIZE: reset only the previous transparent
+                  g->pal[i][3] = 255; 
+               if (g->transparent >= 0 && (g->eflags & 0x01))
+                  g->pal[g->transparent][3] = 0;
+               g->color_table = (uint8 *) g->pal;
+            } else
+               return epuc("missing color table", "Corrupt GIF");
+   
+            o = stbi_process_gif_raster(s, g);
+            if (o == NULL) return NULL;
+
+            if (req_comp && req_comp != 4)
+               o = convert_format(o, 4, req_comp, g->w, g->h);
+            return o;
+         }
+
+         case 0x21: // Comment Extension.
+         {
+            int len;
+            if (get8(s) == 0xF9) { // Graphic Control Extension.
+               len = get8(s);
+               if (len == 4) {
+                  g->eflags = get8(s);
+                  get16le(s); // delay
+                  g->transparent = get8(s);
+               } else {
+                  skip(s, len);
+                  break;
+               }
+            }
+            while ((len = get8(s)) != 0)
+               skip(s, len);
+            break;
+         }
+
+         case 0x3B: // gif stream termination code
+            return (uint8 *) 1;
+
+         default:
+            return epuc("unknown code", "Corrupt GIF");
+      }
+   }
+}
+
+static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   uint8 *u = 0;
+   stbi_gif g={0};
+
+   u = stbi_gif_load_next(s, &g, comp, req_comp);
+   if (u == (void *) 1) u = 0;  // end of animated gif marker
+   if (u) {
+      *x = g.w;
+      *y = g.h;
+   }
+
+   return u;
+}
+
+static int stbi_gif_info(stbi *s, int *x, int *y, int *comp)
+{
+   return stbi_gif_info_raw(s,x,y,comp);
+}
+
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int hdr_test(stbi *s)
+{
+   const char *signature = "#?RADIANCE\n";
+   int i;
+   for (i=0; signature[i]; ++i)
+      if (get8(s) != signature[i])
+         return 0;
+   return 1;
+}
+
+static int stbi_hdr_test(stbi* s)
+{
+   int r = hdr_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+#define HDR_BUFLEN  1024
+static char *hdr_gettoken(stbi *z, char *buffer)
+{
+   int len=0;
+   char c = '\0';
+
+   c = (char) get8(z);
+
+   while (!at_eof(z) && c != '\n') {
+      buffer[len++] = c;
+      if (len == HDR_BUFLEN-1) {
+         // flush to end of line
+         while (!at_eof(z) && get8(z) != '\n')
+            ;
+         break;
+      }
+      c = (char) get8(z);
+   }
+
+   buffer[len] = 0;
+   return buffer;
+}
+
+static void hdr_convert(float *output, stbi_uc *input, int req_comp)
+{
+   if ( input[3] != 0 ) {
+      float f1;
+      // Exponent
+      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
+      if (req_comp <= 2)
+         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+      else {
+         output[0] = input[0] * f1;
+         output[1] = input[1] * f1;
+         output[2] = input[2] * f1;
+      }
+      if (req_comp == 2) output[1] = 1;
+      if (req_comp == 4) output[3] = 1;
+   } else {
+      switch (req_comp) {
+         case 4: output[3] = 1; /* fallthrough */
+         case 3: output[0] = output[1] = output[2] = 0;
+                 break;
+         case 2: output[1] = 1; /* fallthrough */
+         case 1: output[0] = 0;
+                 break;
+      }
+   }
+}
+
+static float *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   char buffer[HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int width, height;
+   stbi_uc *scanline;
+   float *hdr_data;
+   int len;
+   unsigned char count, value;
+   int i, j, k, c1,c2, z;
+
+
+   // Check identifier
+   if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0)
+      return epf("not HDR", "Corrupt HDR image");
+   
+   // Parse header
+   for(;;) {
+      token = hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid)    return epf("unsupported format", "Unsupported HDR format");
+
+   // Parse width and height
+   // can't use sscanf() if we're not using stdio!
+   token = hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   height = strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   width = strtol(token, NULL, 10);
+
+   *x = width;
+   *y = height;
+
+   *comp = 3;
+   if (req_comp == 0) req_comp = 3;
+
+   // Read data
+   hdr_data = (float *) malloc(height * width * req_comp * sizeof(float));
+
+   // Load image data
+   // image data is stored as some number of sca
+   if ( width < 8 || width >= 32768) {
+      // Read flat data
+      for (j=0; j < height; ++j) {
+         for (i=0; i < width; ++i) {
+            stbi_uc rgbe[4];
+           main_decode_loop:
+            getn(s, rgbe, 4);
+            hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+         }
+      }
+   } else {
+      // Read RLE-encoded data
+      scanline = NULL;
+
+      for (j = 0; j < height; ++j) {
+         c1 = get8(s);
+         c2 = get8(s);
+         len = get8(s);
+         if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+            // not run-length encoded, so we have to actually use THIS data as a decoded
+            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+            uint8 rgbe[4];
+            rgbe[0] = (uint8) c1;
+            rgbe[1] = (uint8) c2;
+            rgbe[2] = (uint8) len;
+            rgbe[3] = (uint8) get8u(s);
+            hdr_convert(hdr_data, rgbe, req_comp);
+            i = 1;
+            j = 0;
+            free(scanline);
+            goto main_decode_loop; // yes, this makes no sense
+         }
+         len <<= 8;
+         len |= get8(s);
+         if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); }
+         if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4);
+            
+         for (k = 0; k < 4; ++k) {
+            i = 0;
+            while (i < width) {
+               count = get8u(s);
+               if (count > 128) {
+                  // Run
+                  value = get8u(s);
+                  count -= 128;
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = value;
+               } else {
+                  // Dump
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = get8u(s);
+               }
+            }
+         }
+         for (i=0; i < width; ++i)
+            hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+      }
+      free(scanline);
+   }
+
+   return hdr_data;
+}
+
+static float *stbi_hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   return hdr_load(s,x,y,comp,req_comp);
+}
+
+static int stbi_hdr_info(stbi *s, int *x, int *y, int *comp)
+{
+   char buffer[HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+
+   if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0) {
+       stbi_rewind( s );
+       return 0;
+   }
+
+   for(;;) {
+      token = hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid) {
+       stbi_rewind( s );
+       return 0;
+   }
+   token = hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3)) {
+       stbi_rewind( s );
+       return 0;
+   }
+   token += 3;
+   *y = strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3)) {
+       stbi_rewind( s );
+       return 0;
+   }
+   token += 3;
+   *x = strtol(token, NULL, 10);
+   *comp = 3;
+   return 1;
+}
+#endif // STBI_NO_HDR
+
+static int stbi_bmp_info(stbi *s, int *x, int *y, int *comp)
+{
+   int hsz;
+   if (get8(s) != 'B' || get8(s) != 'M') {
+       stbi_rewind( s );
+       return 0;
+   }
+   skip(s,12);
+   hsz = get32le(s);
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) {
+       stbi_rewind( s );
+       return 0;
+   }
+   if (hsz == 12) {
+      *x = get16le(s);
+      *y = get16le(s);
+   } else {
+      *x = get32le(s);
+      *y = get32le(s);
+   }
+   if (get16le(s) != 1) {
+       stbi_rewind( s );
+       return 0;
+   }
+   *comp = get16le(s) / 8;
+   return 1;
+}
+
+static int stbi_psd_info(stbi *s, int *x, int *y, int *comp)
+{
+   int channelCount;
+   if (get32(s) != 0x38425053) {
+       stbi_rewind( s );
+       return 0;
+   }
+   if (get16(s) != 1) {
+       stbi_rewind( s );
+       return 0;
+   }
+   skip(s, 6);
+   channelCount = get16(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi_rewind( s );
+       return 0;
+   }
+   *y = get32(s);
+   *x = get32(s);
+   if (get16(s) != 8) {
+       stbi_rewind( s );
+       return 0;
+   }
+   if (get16(s) != 3) {
+       stbi_rewind( s );
+       return 0;
+   }
+   *comp = 4;
+   return 1;
+}
+
+static int stbi_pic_info(stbi *s, int *x, int *y, int *comp)
+{
+   int act_comp=0,num_packets=0,chained;
+   pic_packet_t packets[10];
+
+   skip(s, 92);
+
+   *x = get16(s);
+   *y = get16(s);
+   if (at_eof(s))  return 0;
+   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+       stbi_rewind( s );
+       return 0;
+   }
+
+   skip(s, 8);
+
+   do {
+      pic_packet_t *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return 0;
+
+      packet = &packets[num_packets++];
+      chained = get8(s);
+      packet->size    = get8u(s);
+      packet->type    = get8u(s);
+      packet->channel = get8u(s);
+      act_comp |= packet->channel;
+
+      if (at_eof(s)) {
+          stbi_rewind( s );
+          return 0;
+      }
+      if (packet->size != 8) {
+          stbi_rewind( s );
+          return 0;
+      }
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3);
+
+   return 1;
+}
+
+static int stbi_info_main(stbi *s, int *x, int *y, int *comp)
+{
+   if (stbi_jpeg_info(s, x, y, comp))
+       return 1;
+   if (stbi_png_info(s, x, y, comp))
+       return 1;
+   if (stbi_gif_info(s, x, y, comp))
+       return 1;
+   if (stbi_bmp_info(s, x, y, comp))
+       return 1;
+   if (stbi_psd_info(s, x, y, comp))
+       return 1;
+   if (stbi_pic_info(s, x, y, comp))
+       return 1;
+   #ifndef STBI_NO_HDR
+   if (stbi_hdr_info(s, x, y, comp))
+       return 1;
+   #endif
+   // test tga last because it's a crappy test!
+   if (stbi_tga_info(s, x, y, comp))
+       return 1;
+   return e("unknown image type", "Image not of any known type, or corrupt");
+}
+
+#ifndef STBI_NO_STDIO
+int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+    FILE *f = fopen(filename, "rb");
+    int result;
+    if (!f) return e("can't fopen", "Unable to open file");
+    result = stbi_info_from_file(f, x, y, comp);
+    fclose(f);
+    return result;
+}
+
+int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+   int r;
+   stbi s;
+   long pos = ftell(f);
+   start_file(&s, f);
+   r = stbi_info_main(&s,x,y,comp);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+#endif // !STBI_NO_STDIO
+
+int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+   stbi s;
+   start_mem(&s,buffer,len);
+   return stbi_info_main(&s,x,y,comp);
+}
+
+int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+   stbi s;
+   start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi_info_main(&s,x,y,comp);
+}
+
+#endif // STBI_HEADER_FILE_ONLY
+
+/*
+   revision history:
+      1.33 (2011-07-14)
+             make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
+      1.32 (2011-07-13)
+             support for "info" function for all supported filetypes (SpartanJ)
+      1.31 (2011-06-20)
+             a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30 (2011-06-11)
+             added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
+             removed deprecated format-specific test/load functions
+             removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
+             error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
+             fix inefficiency in decoding 32-bit BMP (David Woo)
+      1.29 (2010-08-16)
+             various warning fixes from Aurelien Pocheville 
+      1.28 (2010-08-01)
+             fix bug in GIF palette transparency (SpartanJ)
+      1.27 (2010-08-01)
+             cast-to-uint8 to fix warnings
+      1.26 (2010-07-24)
+             fix bug in file buffering for PNG reported by SpartanJ
+      1.25 (2010-07-17)
+             refix trans_data warning (Won Chun)
+      1.24 (2010-07-12)
+             perf improvements reading from files on platforms with lock-heavy fgetc()
+             minor perf improvements for jpeg
+             deprecated type-specific functions so we'll get feedback if they're needed
+             attempt to fix trans_data warning (Won Chun)
+      1.23   fixed bug in iPhone support
+      1.22 (2010-07-10)
+             removed image *writing* support
+             stbi_info support from Jetro Lauha
+             GIF support from Jean-Marc Lienher
+             iPhone PNG-extensions from James Brown
+             warning-fixes from Nicolas Schulz and Janez Zemva (i.e. Janez (U+017D)emva)
+      1.21   fix use of 'uint8' in header (reported by jon blow)
+      1.20   added support for Softimage PIC, by Tom Seddon
+      1.19   bug in interlaced PNG corruption check (found by ryg)
+      1.18 2008-08-02
+             fix a threading bug (local mutable static)
+      1.17   support interlaced PNG
+      1.16   major bugfix - convert_format converted one too many pixels
+      1.15   initialize some fields for thread safety
+      1.14   fix threadsafe conversion bug
+             header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+      1.13   threadsafe
+      1.12   const qualifiers in the API
+      1.11   Support installable IDCT, colorspace conversion routines
+      1.10   Fixes for 64-bit (don't use "unsigned long")
+             optimized upsampling by Fabian "ryg" Giesen
+      1.09   Fix format-conversion for PSD code (bad global variables!)
+      1.08   Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+      1.07   attempt to fix C++ warning/errors again
+      1.06   attempt to fix C++ warning/errors again
+      1.05   fix TGA loading to return correct *comp and use good luminance calc
+      1.04   default float alpha is 1, not 255; use 'void *' for stbi_image_free
+      1.03   bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+      1.02   support for (subset of) HDR files, float interface for preferred access to them
+      1.01   fix bug: possible bug in handling right-side up bmps... not sure
+             fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all
+      1.00   interface to zlib that skips zlib header
+      0.99   correct handling of alpha in palette
+      0.98   TGA loader by lonesock; dynamically add loaders (untested)
+      0.97   jpeg errors on too large a file; also catch another malloc failure
+      0.96   fix detection of invalid v value - particleman@mollyrocket forum
+      0.95   during header scan, seek to markers in case of padding
+      0.94   STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+      0.93   handle jpegtran output; verbose errors
+      0.92   read 4,8,16,24,32-bit BMP files of several formats
+      0.91   output 24-bit Windows 3.0 BMP files
+      0.90   fix a few more warnings; bump version number to approach 1.0
+      0.61   bugfixes due to Marc LeBlanc, Christopher Lloyd
+      0.60   fix compiling as c++
+      0.59   fix warnings: merge Dave Moore's -Wall fixes
+      0.58   fix bug: zlib uncompressed mode len/nlen was wrong endian
+      0.57   fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+      0.56   fix bug: zlib uncompressed mode len vs. nlen
+      0.55   fix bug: restart_interval not initialized to 0
+      0.54   allow NULL for 'int *comp'
+      0.53   fix bug in png 3->4; speedup png decoding
+      0.52   png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+      0.51   obey req_comp requests, 1-component jpegs return as 1-component,
+             on 'test' only check type, not whether we support this variant
+      0.50   first released version
+*/

stb_image_write.h

@@ -0,0 +1,511 @@
+/* stbiw-0.92 - public domain - http://nothings.org/stb/stb_image_write.h
+   writes out PNG/BMP/TGA images to C stdio - Sean Barrett 2010
+                            no warranty implied; use at your own risk
+
+
+Before including,
+
+    #define STB_IMAGE_WRITE_IMPLEMENTATION
+
+in the file that you want to have the implementation.
+
+
+ABOUT:
+
+   This header file is a library for writing images to C stdio. It could be
+   adapted to write to memory or a general streaming interface; let me know.
+
+   The PNG output is not optimal; it is 20-50% larger than the file
+   written by a decent optimizing implementation. This library is designed
+   for source code compactness and simplicitly, not optimal image file size
+   or run-time performance.
+
+USAGE:
+
+   There are three functions, one for each image file format:
+
+     int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+     int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+     int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+
+   Each function returns 0 on failure and non-0 on success.
+   
+   The functions create an image file defined by the parameters. The image
+   is a rectangle of pixels stored from left-to-right, top-to-bottom.
+   Each pixel contains 'comp' channels of data stored interleaved with 8-bits
+   per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
+   monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
+   The *data pointer points to the first byte of the top-left-most pixel.
+   For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
+   a row of pixels to the first byte of the next row of pixels.
+
+   PNG creates output files with the same number of components as the input.
+   The BMP and TGA formats expand Y to RGB in the file format. BMP does not
+   output alpha.
+   
+   PNG supports writing rectangles of data even when the bytes storing rows of
+   data are not consecutive in memory (e.g. sub-rectangles of a larger image),
+   by supplying the stride between the beginning of adjacent rows. The other
+   formats do not. (Thus you cannot write a native-format BMP through the BMP
+   writer, both because it is in BGR order and because it may have padding
+   at the end of the line.)
+*/
+
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
+#define INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+extern int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+extern int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif//INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+typedef unsigned int stbiw_uint32;
+typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
+
+static void writefv(FILE *f, const char *fmt, va_list v)
+{
+   while (*fmt) {
+      switch (*fmt++) {
+         case ' ': break;
+         case '1': { unsigned char x = (unsigned char) va_arg(v, int); fputc(x,f); break; }
+         case '2': { int x = va_arg(v,int); unsigned char b[2];
+                     b[0] = (unsigned char) x; b[1] = (unsigned char) (x>>8);
+                     fwrite(b,2,1,f); break; }
+         case '4': { stbiw_uint32 x = va_arg(v,int); unsigned char b[4];
+                     b[0]=(unsigned char)x; b[1]=(unsigned char)(x>>8);
+                     b[2]=(unsigned char)(x>>16); b[3]=(unsigned char)(x>>24);
+                     fwrite(b,4,1,f); break; }
+         default:
+            assert(0);
+            return;
+      }
+   }
+}
+
+static void write3(FILE *f, unsigned char a, unsigned char b, unsigned char c)
+{
+   unsigned char arr[3];
+   arr[0] = a, arr[1] = b, arr[2] = c;
+   fwrite(arr, 3, 1, f);
+}
+
+static void write_pixels(FILE *f, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad)
+{
+   unsigned char bg[3] = { 255, 0, 255}, px[3];
+   stbiw_uint32 zero = 0;
+   int i,j,k, j_end;
+
+   if (y <= 0)
+      return;
+
+   if (vdir < 0) 
+      j_end = -1, j = y-1;
+   else
+      j_end =  y, j = 0;
+
+   for (; j != j_end; j += vdir) {
+      for (i=0; i < x; ++i) {
+         unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
+         if (write_alpha < 0)
+            fwrite(&d[comp-1], 1, 1, f);
+         switch (comp) {
+            case 1:
+            case 2: write3(f, d[0],d[0],d[0]);
+                    break;
+            case 4:
+               if (!write_alpha) {
+                  // composite against pink background
+                  for (k=0; k < 3; ++k)
+                     px[k] = bg[k] + ((d[k] - bg[k]) * d[3])/255;
+                  write3(f, px[1-rgb_dir],px[1],px[1+rgb_dir]);
+                  break;
+               }
+               /* FALLTHROUGH */
+            case 3:
+               write3(f, d[1-rgb_dir],d[1],d[1+rgb_dir]);
+               break;
+         }
+         if (write_alpha > 0)
+            fwrite(&d[comp-1], 1, 1, f);
+      }
+      fwrite(&zero,scanline_pad,1,f);
+   }
+}
+
+static int outfile(char const *filename, int rgb_dir, int vdir, int x, int y, int comp, void *data, int alpha, int pad, const char *fmt, ...)
+{
+   FILE *f;
+   if (y < 0 || x < 0) return 0;
+   f = fopen(filename, "wb");
+   if (f) {
+      va_list v;
+      va_start(v, fmt);
+      writefv(f, fmt, v);
+      va_end(v);
+      write_pixels(f,rgb_dir,vdir,x,y,comp,data,alpha,pad);
+      fclose(f);
+   }
+   return f != NULL;
+}
+
+int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
+{
+   int pad = (-x*3) & 3;
+   return outfile(filename,-1,-1,x,y,comp,(void *) data,0,pad,
+           "11 4 22 4" "4 44 22 444444",
+           'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,  // file header
+            40, x,y, 1,24, 0,0,0,0,0,0);             // bitmap header
+}
+
+int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
+{
+   int has_alpha = !(comp & 1);
+   return outfile(filename, -1,-1, x, y, comp, (void *) data, has_alpha, 0,
+                  "111 221 2222 11", 0,0,2, 0,0,0, 0,0,x,y, 24+8*has_alpha, 8*has_alpha);
+}
+
+// stretchy buffer; stbi__sbpush() == vector<>::push_back() -- stbi__sbcount() == vector<>::size()
+#define stbi__sbraw(a) ((int *) (a) - 2)
+#define stbi__sbm(a)   stbi__sbraw(a)[0]
+#define stbi__sbn(a)   stbi__sbraw(a)[1]
+
+#define stbi__sbneedgrow(a,n)  ((a)==0 || stbi__sbn(a)+n >= stbi__sbm(a))
+#define stbi__sbmaybegrow(a,n) (stbi__sbneedgrow(a,(n)) ? stbi__sbgrow(a,n) : 0)
+#define stbi__sbgrow(a,n)  stbi__sbgrowf((void **) &(a), (n), sizeof(*(a)))
+
+#define stbi__sbpush(a, v)      (stbi__sbmaybegrow(a,1), (a)[stbi__sbn(a)++] = (v))
+#define stbi__sbcount(a)        ((a) ? stbi__sbn(a) : 0)
+#define stbi__sbfree(a)         ((a) ? free(stbi__sbraw(a)),0 : 0)
+
+static void *stbi__sbgrowf(void **arr, int increment, int itemsize)
+{
+   int m = *arr ? 2*stbi__sbm(*arr)+increment : increment+1;
+   void *p = realloc(*arr ? stbi__sbraw(*arr) : 0, itemsize * m + sizeof(int)*2);
+   assert(p);
+   if (p) {
+      if (!*arr) ((int *) p)[1] = 0;
+      *arr = (void *) ((int *) p + 2);
+      stbi__sbm(*arr) = m;
+   }
+   return *arr;
+}
+
+static unsigned char *stbi__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
+{
+   while (*bitcount >= 8) {
+      stbi__sbpush(data, (unsigned char) *bitbuffer);
+      *bitbuffer >>= 8;
+      *bitcount -= 8;
+   }
+   return data;
+}
+
+static int stbi__zlib_bitrev(int code, int codebits)
+{
+   int res=0;
+   while (codebits--) {
+      res = (res << 1) | (code & 1);
+      code >>= 1;
+   }
+   return res;
+}
+
+static unsigned int stbi__zlib_countm(unsigned char *a, unsigned char *b, int limit)
+{
+   int i;
+   for (i=0; i < limit && i < 258; ++i)
+      if (a[i] != b[i]) break;
+   return i;
+}
+
+static unsigned int stbi__zhash(unsigned char *data)
+{
+   stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
+   hash ^= hash << 3;
+   hash += hash >> 5;
+   hash ^= hash << 4;
+   hash += hash >> 17;
+   hash ^= hash << 25;
+   hash += hash >> 6;
+   return hash;
+}
+
+#define stbi__zlib_flush() (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))
+#define stbi__zlib_add(code,codebits) \
+      (bitbuf |= (code) << bitcount, bitcount += (codebits), stbi__zlib_flush())
+#define stbi__zlib_huffa(b,c)  stbi__zlib_add(stbi__zlib_bitrev(b,c),c)
+// default huffman tables
+#define stbi__zlib_huff1(n)  stbi__zlib_huffa(0x30 + (n), 8)
+#define stbi__zlib_huff2(n)  stbi__zlib_huffa(0x190 + (n)-144, 9)
+#define stbi__zlib_huff3(n)  stbi__zlib_huffa(0 + (n)-256,7)
+#define stbi__zlib_huff4(n)  stbi__zlib_huffa(0xc0 + (n)-280,8)
+#define stbi__zlib_huff(n)  ((n) <= 143 ? stbi__zlib_huff1(n) : (n) <= 255 ? stbi__zlib_huff2(n) : (n) <= 279 ? stbi__zlib_huff3(n) : stbi__zlib_huff4(n))
+#define stbi__zlib_huffb(n) ((n) <= 143 ? stbi__zlib_huff1(n) : stbi__zlib_huff2(n))
+
+#define stbi__ZHASH   16384
+
+unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
+{
+   static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
+   static unsigned char  lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0 };
+   static unsigned short distc[]   = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
+   static unsigned char  disteb[]  = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
+   unsigned int bitbuf=0;
+   int i,j, bitcount=0;
+   unsigned char *out = NULL;
+   unsigned char **hash_table[stbi__ZHASH]; // 64KB on the stack!
+   if (quality < 5) quality = 5;
+
+   stbi__sbpush(out, 0x78);   // DEFLATE 32K window
+   stbi__sbpush(out, 0x5e);   // FLEVEL = 1
+   stbi__zlib_add(1,1);  // BFINAL = 1
+   stbi__zlib_add(1,2);  // BTYPE = 1 -- fixed huffman
+
+   for (i=0; i < stbi__ZHASH; ++i)
+      hash_table[i] = NULL;
+
+   i=0;
+   while (i < data_len-3) {
+      // hash next 3 bytes of data to be compressed 
+      int h = stbi__zhash(data+i)&(stbi__ZHASH-1), best=3;
+      unsigned char *bestloc = 0;
+      unsigned char **hlist = hash_table[h];
+      int n = stbi__sbcount(hlist);
+      for (j=0; j < n; ++j) {
+         if (hlist[j]-data > i-32768) { // if entry lies within window
+            int d = stbi__zlib_countm(hlist[j], data+i, data_len-i);
+            if (d >= best) best=d,bestloc=hlist[j];
+         }
+      }
+      // when hash table entry is too long, delete half the entries
+      if (hash_table[h] && stbi__sbn(hash_table[h]) == 2*quality) {
+         memcpy(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
+         stbi__sbn(hash_table[h]) = quality;
+      }
+      stbi__sbpush(hash_table[h],data+i);
+
+      if (bestloc) {
+         // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
+         h = stbi__zhash(data+i+1)&(stbi__ZHASH-1);
+         hlist = hash_table[h];
+         n = stbi__sbcount(hlist);
+         for (j=0; j < n; ++j) {
+            if (hlist[j]-data > i-32767) {
+               int e = stbi__zlib_countm(hlist[j], data+i+1, data_len-i-1);
+               if (e > best) { // if next match is better, bail on current match
+                  bestloc = NULL;
+                  break;
+               }
+            }
+         }
+      }
+
+      if (bestloc) {
+         int d = data+i - bestloc; // distance back
+         assert(d <= 32767 && best <= 258);
+         for (j=0; best > lengthc[j+1]-1; ++j);
+         stbi__zlib_huff(j+257);
+         if (lengtheb[j]) stbi__zlib_add(best - lengthc[j], lengtheb[j]);
+         for (j=0; d > distc[j+1]-1; ++j);
+         stbi__zlib_add(stbi__zlib_bitrev(j,5),5);
+         if (disteb[j]) stbi__zlib_add(d - distc[j], disteb[j]);
+         i += best;
+      } else {
+         stbi__zlib_huffb(data[i]);
+         ++i;
+      }
+   }
+   // write out final bytes
+   for (;i < data_len; ++i)
+      stbi__zlib_huffb(data[i]);
+   stbi__zlib_huff(256); // end of block
+   // pad with 0 bits to byte boundary
+   while (bitcount)
+      stbi__zlib_add(0,1);
+
+   for (i=0; i < stbi__ZHASH; ++i)
+      (void) stbi__sbfree(hash_table[i]);
+
+   {
+      // compute adler32 on input
+      unsigned int i=0, s1=1, s2=0, blocklen = data_len % 5552;
+      int j=0;
+      while (j < data_len) {
+         for (i=0; i < blocklen; ++i) s1 += data[j+i], s2 += s1;
+         s1 %= 65521, s2 %= 65521;
+         j += blocklen;
+         blocklen = 5552;
+      }
+      stbi__sbpush(out, (unsigned char) (s2 >> 8));
+      stbi__sbpush(out, (unsigned char) s2);
+      stbi__sbpush(out, (unsigned char) (s1 >> 8));
+      stbi__sbpush(out, (unsigned char) s1);
+   }
+   *out_len = stbi__sbn(out);
+   // make returned pointer freeable
+   memmove(stbi__sbraw(out), out, *out_len);
+   return (unsigned char *) stbi__sbraw(out);
+}
+
+unsigned int stbi__crc32(unsigned char *buffer, int len)
+{
+   static unsigned int crc_table[256];
+   unsigned int crc = ~0u;
+   int i,j;
+   if (crc_table[1] == 0)
+      for(i=0; i < 256; i++)
+         for (crc_table[i]=i, j=0; j < 8; ++j)
+            crc_table[i] = (crc_table[i] >> 1) ^ (crc_table[i] & 1 ? 0xedb88320 : 0);
+   for (i=0; i < len; ++i)
+      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
+   return ~crc;
+}
+
+#define stbi__wpng4(o,a,b,c,d) ((o)[0]=(unsigned char)(a),(o)[1]=(unsigned char)(b),(o)[2]=(unsigned char)(c),(o)[3]=(unsigned char)(d),(o)+=4)
+#define stbi__wp32(data,v) stbi__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
+#define stbi__wptag(data,s) stbi__wpng4(data, s[0],s[1],s[2],s[3])
+
+static void stbi__wpcrc(unsigned char **data, int len)
+{
+   unsigned int crc = stbi__crc32(*data - len - 4, len+4);
+   stbi__wp32(*data, crc);
+}
+
+static unsigned char stbi__paeth(int a, int b, int c)
+{
+   int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return (unsigned char) a;
+   if (pb <= pc) return (unsigned char) b;
+   return (unsigned char) c;
+}
+
+unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
+{
+   int ctype[5] = { -1, 0, 4, 2, 6 };
+   unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
+   unsigned char *out,*o, *filt, *zlib;
+   signed char *line_buffer;
+   int i,j,k,p,zlen;
+
+   if (stride_bytes == 0)
+      stride_bytes = x * n;
+
+   filt = (unsigned char *) malloc((x*n+1) * y); if (!filt) return 0;
+   line_buffer = (signed char *) malloc(x * n); if (!line_buffer) { free(filt); return 0; }
+   for (j=0; j < y; ++j) {
+      static int mapping[] = { 0,1,2,3,4 };
+      static int firstmap[] = { 0,1,0,5,6 };
+      int *mymap = j ? mapping : firstmap;
+      int best = 0, bestval = 0x7fffffff;
+      for (p=0; p < 2; ++p) {
+         for (k= p?best:0; k < 5; ++k) {
+            int type = mymap[k],est=0;
+            unsigned char *z = pixels + stride_bytes*j;
+            for (i=0; i < n; ++i)
+               switch (type) {
+                  case 0: line_buffer[i] = z[i]; break;
+                  case 1: line_buffer[i] = z[i]; break;
+                  case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
+                  case 3: line_buffer[i] = z[i] - (z[i-stride_bytes]>>1); break;
+                  case 4: line_buffer[i] = (signed char) (z[i] - stbi__paeth(0,z[i-stride_bytes],0)); break;
+                  case 5: line_buffer[i] = z[i]; break;
+                  case 6: line_buffer[i] = z[i]; break;
+               }
+            for (i=n; i < x*n; ++i) {
+               switch (type) {
+                  case 0: line_buffer[i] = z[i]; break;
+                  case 1: line_buffer[i] = z[i] - z[i-n]; break;
+                  case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
+                  case 3: line_buffer[i] = z[i] - ((z[i-n] + z[i-stride_bytes])>>1); break;
+                  case 4: line_buffer[i] = z[i] - stbi__paeth(z[i-n], z[i-stride_bytes], z[i-stride_bytes-n]); break;
+                  case 5: line_buffer[i] = z[i] - (z[i-n]>>1); break;
+                  case 6: line_buffer[i] = z[i] - stbi__paeth(z[i-n], 0,0); break;
+               }
+            }
+            if (p) break;
+            for (i=0; i < x*n; ++i)
+               est += abs((signed char) line_buffer[i]);
+            if (est < bestval) { bestval = est; best = k; }
+         }
+      }
+      // when we get here, best contains the filter type, and line_buffer contains the data
+      filt[j*(x*n+1)] = (unsigned char) best;
+      memcpy(filt+j*(x*n+1)+1, line_buffer, x*n);
+   }
+   free(line_buffer);
+   zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, 8); // increase 8 to get smaller but use more memory
+   free(filt);
+   if (!zlib) return 0;
+
+   // each tag requires 12 bytes of overhead
+   out = (unsigned char *) malloc(8 + 12+13 + 12+zlen + 12); 
+   if (!out) return 0;
+   *out_len = 8 + 12+13 + 12+zlen + 12;
+
+   o=out;
+   memcpy(o,sig,8); o+= 8;
+   stbi__wp32(o, 13); // header length
+   stbi__wptag(o, "IHDR");
+   stbi__wp32(o, x);
+   stbi__wp32(o, y);
+   *o++ = 8;
+   *o++ = (unsigned char) ctype[n];
+   *o++ = 0;
+   *o++ = 0;
+   *o++ = 0;
+   stbi__wpcrc(&o,13);
+
+   stbi__wp32(o, zlen);
+   stbi__wptag(o, "IDAT");
+   memcpy(o, zlib, zlen); o += zlen; free(zlib);
+   stbi__wpcrc(&o, zlen);
+
+   stbi__wp32(o,0);
+   stbi__wptag(o, "IEND");
+   stbi__wpcrc(&o,0);
+
+   assert(o == out + *out_len);
+
+   return out;
+}
+
+int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
+{
+   FILE *f;
+   int len;
+   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
+   if (!png) return 0;
+   f = fopen(filename, "wb");
+   if (!f) { free(png); return 0; }
+   fwrite(png, 1, len, f);
+   fclose(f);
+   free(png);
+   return 1;
+}
+#endif // STB_IMAGE_WRITE_IMPLEMENTATION
+
+/* Revision history
+
+      0.92 (2010-08-01)
+             casts to unsigned char to fix warnings
+      0.91 (2010-07-17)
+             first public release
+      0.90   first internal release
+*/

stb_perlin.h

@@ -0,0 +1,175 @@
+// stb_perlin.h -- perlin noise -- v0.2
+// public domain single-file C implementation by Sean Barrett
+//
+// to create the implementation,
+//     #define STB_PERLIN_IMPLEMENTATION
+// in *one* C/CPP file that includes this file.
+
+
+// Documentation:
+//
+// float  stb_perlin_noise3( float x,
+//                           float y,
+//                           float z,
+//                           int   x_wrap=0,
+//                           int   y_wrap=0,
+//                           int   z_wrap=0)
+//
+// This function computes a random value at the coordinate (x,y,z).
+// Adjacent random values are continuous but the noise fluctuates
+// its randomness with period 1, i.e. takes on wholly unrelated values
+// at integer points. Specifically, this implements Ken Perlin's
+// revised noise function from 2002.
+//
+// The "wrap" parameters can be used to create wraparound noise that
+// wraps at powers of two. The numbers MUST be powers of two. Specify
+// 0 to mean "don't care". (The noise always wraps every 256 due
+// details of the implementation, even if you ask for larger or no
+// wrapping.)
+
+
+#ifdef __cplusplus
+extern "C" float stb_perlin_noise3(float x, float y, float z, int x_wrap=0, int y_wrap=0, int z_wrap=0);
+#else
+extern float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap);
+#endif
+
+#ifdef STB_PERLIN_IMPLEMENTATION
+
+#include <math.h> // floor()
+
+// not same permutation table as Perlin's reference to avoid copyright issues;
+// Perlin's table can be found at http://mrl.nyu.edu/~perlin/noise/
+// @OPTIMIZE: should this be unsigned char instead of int for cache?
+static int stb__perlin_randtab[512] =
+{
+   23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123, 
+   152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72, 
+   175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240, 
+   8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57, 
+   225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233, 
+   94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172, 
+   165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243, 
+   65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122, 
+   26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76, 
+   250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246, 
+   132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3, 
+   91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231, 
+   38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221, 
+   131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62, 
+   27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135, 
+   61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,  
+
+   // and a second copy so we don't need an extra mask or static initializer
+   23, 125, 161, 52, 103, 117, 70, 37, 247, 101, 203, 169, 124, 126, 44, 123, 
+   152, 238, 145, 45, 171, 114, 253, 10, 192, 136, 4, 157, 249, 30, 35, 72, 
+   175, 63, 77, 90, 181, 16, 96, 111, 133, 104, 75, 162, 93, 56, 66, 240, 
+   8, 50, 84, 229, 49, 210, 173, 239, 141, 1, 87, 18, 2, 198, 143, 57, 
+   225, 160, 58, 217, 168, 206, 245, 204, 199, 6, 73, 60, 20, 230, 211, 233, 
+   94, 200, 88, 9, 74, 155, 33, 15, 219, 130, 226, 202, 83, 236, 42, 172, 
+   165, 218, 55, 222, 46, 107, 98, 154, 109, 67, 196, 178, 127, 158, 13, 243, 
+   65, 79, 166, 248, 25, 224, 115, 80, 68, 51, 184, 128, 232, 208, 151, 122, 
+   26, 212, 105, 43, 179, 213, 235, 148, 146, 89, 14, 195, 28, 78, 112, 76, 
+   250, 47, 24, 251, 140, 108, 186, 190, 228, 170, 183, 139, 39, 188, 244, 246, 
+   132, 48, 119, 144, 180, 138, 134, 193, 82, 182, 120, 121, 86, 220, 209, 3, 
+   91, 241, 149, 85, 205, 150, 113, 216, 31, 100, 41, 164, 177, 214, 153, 231, 
+   38, 71, 185, 174, 97, 201, 29, 95, 7, 92, 54, 254, 191, 118, 34, 221, 
+   131, 11, 163, 99, 234, 81, 227, 147, 156, 176, 17, 142, 69, 12, 110, 62, 
+   27, 255, 0, 194, 59, 116, 242, 252, 19, 21, 187, 53, 207, 129, 64, 135, 
+   61, 40, 167, 237, 102, 223, 106, 159, 197, 189, 215, 137, 36, 32, 22, 5,  
+};
+
+static float stb__perlin_lerp(float a, float b, float t)
+{
+   return a + (b-a) * t;
+}
+
+// different grad function from Perlin's, but easy to modify to match reference
+static float stb__perlin_grad(int hash, float x, float y, float z)
+{
+   static float basis[12][4] =
+   {
+      {  1, 1, 0 },
+      { -1, 1, 0 },
+      {  1,-1, 0 },
+      { -1,-1, 0 },
+      {  1, 0, 1 },
+      { -1, 0, 1 },
+      {  1, 0,-1 },
+      { -1, 0,-1 },
+      {  0, 1, 1 },
+      {  0,-1, 1 },
+      {  0, 1,-1 },
+      {  0,-1,-1 },
+   };
+
+   // perlin's gradient has 12 cases so some get used 1/16th of the time
+   // and some 2/16ths. We reduce bias by changing those fractions
+   // to 5/16ths and 6/16ths, and the same 4 cases get the extra weight.
+   static unsigned char indices[64] =
+   {
+      0,1,2,3,4,5,6,7,8,9,10,11,
+      0,9,1,11,
+      0,1,2,3,4,5,6,7,8,9,10,11,
+      0,1,2,3,4,5,6,7,8,9,10,11,
+      0,1,2,3,4,5,6,7,8,9,10,11,
+      0,1,2,3,4,5,6,7,8,9,10,11,
+   };
+
+   // if you use reference permutation table, change 63 below to 15 to match reference
+   float *grad = basis[indices[hash & 63]];
+   return grad[0]*x + grad[1]*y + grad[2]*z;
+}
+
+float stb_perlin_noise3(float x, float y, float z, int x_wrap, int y_wrap, int z_wrap)
+{
+   float u,v,w;
+   float n000,n001,n010,n011,n100,n101,n110,n111;
+   float n00,n01,n10,n11;
+   float n0,n1;
+
+   unsigned int x_mask = (x_wrap-1) & 255;
+   unsigned int y_mask = (y_wrap-1) & 255;
+   unsigned int z_mask = (z_wrap-1) & 255;
+   int px = (int) floor(x);
+   int py = (int) floor(y);
+   int pz = (int) floor(z);
+   int x0 = px & x_mask, x1 = (px+1) & x_mask;
+   int y0 = py & y_mask, y1 = (py+1) & y_mask;
+   int z0 = pz & z_mask, z1 = (pz+1) & z_mask;
+   int r0,r1, r00,r01,r10,r11;
+
+   #define stb__perlin_ease(a)   (((a*6-15)*a + 10) * a * a * a)
+
+   x -= px; u = stb__perlin_ease(x);
+   y -= py; v = stb__perlin_ease(y);
+   z -= pz; w = stb__perlin_ease(z);
+
+   r0 = stb__perlin_randtab[x0];
+   r1 = stb__perlin_randtab[x1];
+
+   r00 = stb__perlin_randtab[r0+y0];
+   r01 = stb__perlin_randtab[r0+y1];
+   r10 = stb__perlin_randtab[r1+y0];
+   r11 = stb__perlin_randtab[r1+y1];
+
+   n000 = stb__perlin_grad(stb__perlin_randtab[r00+z0], x  , y  , z   );
+   n001 = stb__perlin_grad(stb__perlin_randtab[r00+z1], x  , y  , z-1 );
+   n010 = stb__perlin_grad(stb__perlin_randtab[r01+z0], x  , y-1, z   );
+   n011 = stb__perlin_grad(stb__perlin_randtab[r01+z1], x  , y-1, z-1 );
+   n100 = stb__perlin_grad(stb__perlin_randtab[r10+z0], x-1, y  , z   );
+   n101 = stb__perlin_grad(stb__perlin_randtab[r10+z1], x-1, y  , z-1 );
+   n110 = stb__perlin_grad(stb__perlin_randtab[r11+z0], x-1, y-1, z   );
+   n111 = stb__perlin_grad(stb__perlin_randtab[r11+z1], x-1, y-1, z-1 );
+
+   n00 = stb__perlin_lerp(n000,n001,w);
+   n01 = stb__perlin_lerp(n010,n011,w);
+   n10 = stb__perlin_lerp(n100,n101,w);
+   n11 = stb__perlin_lerp(n110,n111,w);
+
+   n0 = stb__perlin_lerp(n00,n01,v);
+   n1 = stb__perlin_lerp(n10,n11,v);
+
+   return stb__perlin_lerp(n0,n1,u);
+}
+#endif  // STB_PERLIN_IMPLEMENTATION

stb_textedit.h

@@ -0,0 +1,1247 @@
+// stb_textedit.h - v1.1  - public domain - Sean Barrett
+// Development of this library was sponsored by RAD Game Tools
+//
+// This C header file implements the guts of a multi-line text-editing
+// widget; you implement display, word-wrapping, and low-level string
+// insertion/deletion, and stb_textedit will map user inputs into
+// insertions & deletions, plus updates to the cursor position,
+// selection state, and undo state.
+//
+// It is intended for use in games and other systems that need to build
+// their own custom widgets and which do not have heavy text-editing
+// requirements (this library is not recommended for use for editing large
+// texts, as its performance does not scale and it has limited undo).
+//
+// Non-trivial behaviors are modelled after Windows text controls.
+// 
+//
+// LICENSE
+//
+// This software has been placed in the public domain by its author.
+// Where that dedication is not recognized, you are granted a perpetual,
+// irrevocable license to copy and modify this file as you see fit.
+//
+//
+// DEPENDENCIES
+//
+// Uses the C runtime function 'memmove'. Uses no other functions.
+// Performs no runtime allocations.
+//
+//
+// VERSION HISTORY
+//
+//   1.1  (2013-12-15) move-by-word (requires STB_TEXTEDIT_IS_SPACE )
+//   1.0  (2012-07-26) improve documentation, initial public release
+//   0.3  (2012-02-24) bugfixes, single-line mode; insert mode
+//   0.2  (2011-11-28) fixes to undo/redo
+//   0.1  (2010-07-08) initial version
+//
+// ADDITIONAL CONTRIBUTORS
+//
+//   Ulf Winklemann: move-by-word in 1.1
+//
+// USAGE
+//
+// This file behaves differently depending on what symbols you define
+// before including it.
+//
+//
+// Header-file mode:
+//
+//   If you do not define STB_TEXTEDIT_IMPLEMENTATION before including this,
+//   it will operate in "header file" mode. In this mode, it declares a
+//   single public symbol, STB_TexteditState, which encapsulates the current
+//   state of a text widget (except for the string, which you will store
+//   separately).
+//
+//   To compile in this mode, you must define STB_TEXTEDIT_CHARTYPE to a
+//   primitive type that defines a single character (e.g. char, wchar_t, etc).
+//
+//   To save space or increase undo-ability, you can optionally define the
+//   following things that are used by the undo system:
+//
+//      STB_TEXTEDIT_POSITIONTYPE         small int type encoding a valid cursor position
+//      STB_TEXTEDIT_UNDOSTATECOUNT       the number of undo states to allow
+//      STB_TEXTEDIT_UNDOCHARCOUNT        the number of characters to store in the undo buffer
+//
+//   If you don't define these, they are set to permissive types and
+//   moderate sizes. The undo system does no memory allocations, so
+//   it grows STB_TexteditState by the worst-case storage which is (in bytes):
+//
+//        [4 + sizeof(STB_TEXTEDIT_POSITIONTYPE)] * STB_TEXTEDIT_UNDOSTATE_COUNT
+//      +      sizeof(STB_TEXTEDIT_CHARTYPE)      * STB_TEXTEDIT_UNDOCHAR_COUNT
+//
+//
+// Implementation mode:
+//
+//   If you define STB_TEXTEDIT_IMPLEMENTATION before including this, it
+//   will compile the implementation of the text edit widget, depending
+//   on a large number of symbols which must be defined before the include.
+//
+//   The implementation is defined only as static functions. You will then
+//   need to provide your own APIs in the same file which will access the
+//   static functions.
+//
+//   The basic concept is that you provide a "string" object which
+//   behaves like an array of characters. stb_textedit uses indices to
+//   refer to positions in the string, implicitly representing positions
+//   in the displayed textedit. This is true for both plain text and
+//   rich text; even with rich text stb_truetype interacts with your
+//   code as if there was an array of all the displayed characters.
+//
+// Symbols that must be the same in header-file and implementation mode:
+//
+//     STB_TEXTEDIT_CHARTYPE             the character type
+//     STB_TEXTEDIT_POSITIONTYPE         small type that a valid cursor position
+//     STB_TEXTEDIT_UNDOSTATECOUNT       the number of undo states to allow
+//     STB_TEXTEDIT_UNDOCHARCOUNT        the number of characters to store in the undo buffer
+//
+// Symbols you must define for implementation mode:
+//
+//    STB_TEXTEDIT_STRING               the type of object representing a string being edited,
+//                                      typically this is a wrapper object with other data you need
+//
+//    STB_TEXTEDIT_STRINGLEN(obj)       the length of the string (ideally O(1))
+//    STB_TEXTEDIT_LAYOUTROW(&r,obj,n)  returns the results of laying out a line of characters
+//                                        starting from character #n (see discussion below)
+//    STB_TEXTEDIT_GETWIDTH(obj,n,i)    returns the pixel delta from the xpos of the i-1'th
+//                                        character to the i'th char for a line of characters
+//                                        starting at character #n (i.e. accounts for kerning
+//                                        with previous char)
+//    STB_TEXTEDIT_KEYTOTEXT(k)         maps a keyboard input to an insertable character
+//                                        (return type is int, -1 means not valid to insert)
+//    STB_TEXTEDIT_GETCHAR(obj,i)       returns the i'th character of obj, 0-based
+//    STB_TEXTEDIT_NEWLINE              the character returned by _GETCHAR() we recognize
+//                                        as manually wordwrapping for end-of-line positioning
+//
+//    STB_TEXTEDIT_DELETECHARS(obj,i,n)      delete n characters starting at i
+//    STB_TEXTEDIT_INSERTCHARS(obj,i,c*,n)   insert n characters at i (pointed to by STB_TEXTEDIT_CHARTYPE*)
+//
+//    STB_TEXTEDIT_K_SHIFT       a power of two that is or'd in to a keyboard input to represent the shift key
+//
+//    STB_TEXTEDIT_K_LEFT        keyboard input to move cursor left
+//    STB_TEXTEDIT_K_RIGHT       keyboard input to move cursor right
+//    STB_TEXTEDIT_K_UP          keyboard input to move cursor up
+//    STB_TEXTEDIT_K_DOWN        keyboard input to move cursor down
+//    STB_TEXTEDIT_K_LINESTART   keyboard input to move cursor to start of line  // e.g. HOME
+//    STB_TEXTEDIT_K_LINEEND     keyboard input to move cursor to end of line    // e.g. END
+//    STB_TEXTEDIT_K_TEXTSTART   keyboard input to move cursor to start of text  // e.g. ctrl-HOME
+//    STB_TEXTEDIT_K_TEXTEND     keyboard input to move cursor to end of text    // e.g. ctrl-END
+//    STB_TEXTEDIT_K_DELETE      keyboard input to delete selection or character under cursor
+//    STB_TEXTEDIT_K_BACKSPACE   keyboard input to delete selection or character left of cursor
+//    STB_TEXTEDIT_K_UNDO        keyboard input to perform undo
+//    STB_TEXTEDIT_K_REDO        keyboard input to perform redo
+//
+// Optional:
+//    STB_TEXTEDIT_K_INSERT      keyboard input to toggle insert mode
+//    STB_TEXTEDIT_IS_SPACE(ch)  true if character is whitespace (e.g. 'isspace'),
+//                                 required for WORDLEFT/WORDRIGHT
+//    STB_TEXTEDIT_K_WORDLEFT    keyboard input to move cursor left one word // e.g. ctrl-LEFT
+//    STB_TEXTEDIT_K_WORDRIGHT   keyboard input to move cursor right one word // e.g. ctrl-RIGHT
+//
+// Todo:
+//    STB_TEXTEDIT_K_PGUP        keyboard input to move cursor up a page
+//    STB_TEXTEDIT_K_PGDOWN      keyboard input to move cursor down a page
+//
+// Keyboard input must be encoded as a single integer value; e.g. a character code
+// and some bitflags that represent shift states. to simplify the interface, SHIFT must
+// be a bitflag, so we can test the shifted state of cursor movements to allow selection,
+// i.e. (STB_TEXTED_K_RIGHT|STB_TEXTEDIT_K_SHIFT) should be shifted right-arrow.
+//
+// You can encode other things, such as CONTROL or ALT, in additional bits, and
+// then test for their presence in e.g. STB_TEXTEDIT_K_WORDLEFT. For example,
+// my Windows implementations add an additional CONTROL bit, and an additional KEYDOWN
+// bit. Then all of the STB_TEXTEDIT_K_ values bitwise-or in the KEYDOWN bit,
+// and I pass both WM_KEYDOWN and WM_CHAR events to the "key" function in the
+// API below. The control keys will only match WM_KEYDOWN events because of the
+// keydown bit I add, and STB_TEXTEDIT_KEYTOTEXT only tests for the KEYDOWN
+// bit so it only decodes WM_CHAR events.
+//
+// STB_TEXTEDIT_LAYOUTROW returns information about the shape of one displayed
+// row of characters assuming they start on the i'th character--the width and
+// the height and the number of characters consumed. This allows this library
+// to traverse the entire layout incrementally. You need to compute word-wrapping
+// here.
+//
+// Each textfield keeps its own insert mode state, which is not how normal
+// applications work. To keep an app-wide insert mode, update/copy the
+// "insert_mode" field of STB_TexteditState before/after calling API functions.
+//
+// API
+//
+//    void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
+//
+//    void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+//    void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+//    int  stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+//    int  stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)
+//    void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int key)
+//
+//    Each of these functions potentially updates the string and updates the
+//    state.
+//
+//      initialize_state:
+//          set the textedit state to a known good default state when initially
+//          constructing the textedit.
+//
+//      click:
+//          call this with the mouse x,y on a mouse down; it will update the cursor
+//          and reset the selection start/end to the cursor point. the x,y must
+//          be relative to the text widget, with (0,0) being the top left.
+//     
+//      drag:
+//          call this with the mouse x,y on a mouse drag/up; it will update the
+//          cursor and the selection end point
+//     
+//      cut:
+//          call this to delete the current selection; returns true if there was
+//          one. you should FIRST copy the current selection to the system paste buffer.
+//          (To copy, just copy the current selection out of the string yourself.)
+//     
+//      paste:
+//          call this to paste text at the current cursor point or over the current
+//          selection if there is one.
+//     
+//      key:
+//          call this for keyboard inputs sent to the textfield. you can use it
+//          for "key down" events or for "translated" key events. if you need to
+//          do both (as in Win32), or distinguish Unicode characters from control
+//          inputs, set a high bit to distinguish the two; then you can define the
+//          various definitions like STB_TEXTEDIT_K_LEFT have the is-key-event bit
+//          set, and make STB_TEXTEDIT_KEYTOCHAR check that the is-key-event bit is
+//          clear.
+//     
+//   When rendering, you can read the cursor position and selection state from
+//   the STB_TexteditState.
+//
+//
+// Notes:
+//
+// This is designed to be usable in IMGUI, so it allows for the possibility of
+// running in an IMGUI that has NOT cached the multi-line layout. For this
+// reason, it provides an interface that is compatible with computing the
+// layout incrementally--we try to make sure we make as few passes through
+// as possible. (For example, to locate the mouse pointer in the text, we
+// could define functions that return the X and Y positions of characters
+// and binary search Y and then X, but if we're doing dynamic layout this
+// will run the layout algorithm many times, so instead we manually search
+// forward in one pass. Similar logic applies to e.g. up-arrow and
+// down-arrow movement.)
+//
+// If it's run in a widget that *has* cached the layout, then this is less
+// efficient, but it's not horrible on modern computers. But you wouldn't
+// want to edit million-line files with it.
+
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////
+////   Header-file mode
+////
+////
+
+#ifndef INCLUDE_STB_TEXTEDIT_H
+#define INCLUDE_STB_TEXTEDIT_H
+
+////////////////////////////////////////////////////////////////////////
+//
+//     STB_TexteditState
+//
+// Definition of STB_TexteditState which you should store
+// per-textfield; it includes cursor position, selection state,
+// and undo state.
+//
+
+#ifndef STB_TEXTEDIT_UNDOSTATECOUNT
+#define STB_TEXTEDIT_UNDOSTATECOUNT   99
+#endif
+#ifndef STB_TEXTEDIT_UNDOCHARCOUNT
+#define STB_TEXTEDIT_UNDOCHARCOUNT   999
+#endif
+#ifndef STB_TEXTEDIT_CHARTYPE
+#define STB_TEXTEDIT_CHARTYPE        int
+#endif
+#ifndef STB_TEXTEDIT_POSITIONTYPE
+#define STB_TEXTEDIT_POSITIONTYPE    int
+#endif
+
+typedef struct
+{
+   // private data
+   STB_TEXTEDIT_POSITIONTYPE  where;
+   short           insert_length;
+   short           delete_length;
+   short           char_storage;
+} StbUndoRecord;
+
+typedef struct
+{
+   // private data
+   StbUndoRecord          undo_rec [STB_TEXTEDIT_UNDOSTATECOUNT];
+   STB_TEXTEDIT_CHARTYPE  undo_char[STB_TEXTEDIT_UNDOCHARCOUNT];
+   short undo_point, redo_point;
+   short undo_char_point, redo_char_point;
+} StbUndoState;
+
+typedef struct
+{
+   /////////////////////
+   //
+   // public data
+   //
+
+   int cursor;
+   // position of the text cursor within the string
+
+   int select_start;          // selection start point
+   int select_end;
+   // selection start and end point in characters; if equal, no selection.
+   // note that start may be less than or greater than end (e.g. when
+   // dragging the mouse, start is where the initial click was, and you
+   // can drag in either direction)
+
+   unsigned char insert_mode;
+   // each textfield keeps its own insert mode state. to keep an app-wide
+   // insert mode, copy this value in/out of the app state
+
+   /////////////////////
+   //
+   // private data
+   //
+   unsigned char cursor_at_end_of_line; // not implemented yet
+   unsigned char initialized;
+   unsigned char has_preferred_x;
+   unsigned char single_line;
+   unsigned char padding1, padding2, padding3;
+   float preferred_x; // this determines where the cursor up/down tries to seek to along x
+   StbUndoState undostate;
+} STB_TexteditState;
+
+
+////////////////////////////////////////////////////////////////////////
+//
+//     StbTexteditRow
+//
+// Result of layout query, used by stb_textedit to determine where
+// the text in each row is.
+
+// result of layout query
+typedef struct
+{
+   float x0,x1;             // starting x location, end x location (allows for align=right, etc)
+   float baseline_y_delta;  // position of baseline relative to previous row's baseline
+   float ymin,ymax;         // height of row above and below baseline
+   int num_chars;
+} StbTexteditRow;
+#endif //INCLUDE_STB_TEXTEDIT_H
+
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////
+////   Implementation mode
+////
+////
+
+
+// implementation isn't include-guarded, since it might have indirectly
+// included just the "header" portion
+#ifdef STB_TEXTEDIT_IMPLEMENTATION
+
+#include <string.h> // memmove
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Mouse input handling
+//
+
+// traverse the layout to locate the nearest character to a display position
+static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)
+{
+   StbTexteditRow r;
+   int n = STB_TEXTEDIT_STRINGLEN(str);
+   float base_y = 0, prev_x;
+   int i=0, k;
+
+   if (y < 0)
+      return 0;
+
+   r.x0 = r.x1 = 0;
+   r.ymin = r.ymax = 0;
+   r.num_chars = 0;
+
+   // search rows to find one that straddles 'y'
+   while (i < n) {
+      STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+      if (r.num_chars <= 0)
+         return n;
+
+      if (y < base_y + r.ymax)
+         break;
+
+      i += r.num_chars;
+      base_y += r.baseline_y_delta;
+   }
+
+   // below all text, return 'after' last character
+   if (i >= n)
+      return n;
+
+   // check if it's before the beginning of the line
+   if (x < r.x0)
+      return i;
+
+   // check if it's before the end of the line
+   if (x < r.x1) {
+      // search characters in row for one that straddles 'x'
+      k = i;
+      prev_x = r.x0;
+      for (i=0; i < r.num_chars; ++i) {
+         float w = STB_TEXTEDIT_GETWIDTH(str, k, i);
+         if (x < prev_x+w)
+            return k+i;
+         prev_x += w;
+      }
+      // shouldn't happen, but if it does, fall through to end-of-line case
+   }
+
+   // if the last character is a newline, return that. otherwise return 'after' the last character
+   if (STB_TEXTEDIT_GETCHAR(str, i+r.num_chars-1) == STB_TEXTEDIT_NEWLINE)
+      return i+r.num_chars-1;
+   else
+      return i+r.num_chars;
+}
+
+// API click: on mouse down, move the cursor to the clicked location, and reset the selection
+static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+{
+   state->cursor = stb_text_locate_coord(str, x, y);
+   state->select_start = state->cursor;
+   state->select_end = state->cursor;
+   state->has_preferred_x = false;
+}
+
+// API drag: on mouse drag, move the cursor and selection endpoint to the clicked location
+static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+{
+   int p = stb_text_locate_coord(str, x, y);
+   state->cursor = state->select_end = p;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Keyboard input handling
+//
+
+// forward declarations
+static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);
+static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);
+static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length);
+static void stb_text_makeundo_insert(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length);
+static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length);
+
+typedef struct
+{
+   float x,y;    // position of n'th character
+   float height; // height of line
+   int first_char, length; // first char of row, and length
+   int prev_first;  // first char of previous row
+} StbFindState;
+
+// find the x/y location of a character, and remember info about the previous row in
+// case we get a move-up event (for page up, we'll have to rescan)
+static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line)
+{
+   StbTexteditRow r;
+   int prev_start = 0;
+   int z = STB_TEXTEDIT_STRINGLEN(str);
+   int i=0, first;
+
+   if (n == z) {
+      // if it's at the end, then find the last line -- simpler than trying to
+      // explicitly handle this case in the regular code
+      if (single_line) {
+         STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
+         find->y = 0;
+         find->first_char = 0;
+         find->length = z;
+         find->height = r.ymax - r.ymin;
+         find->x = r.x1;
+      } else {
+         find->y = 0;
+         find->x = 0;
+         find->height = 1;
+         while (i < z) {
+            STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+            prev_start = i;
+            i += r.num_chars;
+         }
+         find->first_char = i;
+         find->length = 0;
+         find->prev_first = prev_start;
+      }
+      return;
+   }
+
+   // search rows to find the one that straddles character n
+   find->y = 0;
+
+   for(;;) {
+      STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+      if (n < i + r.num_chars)
+         break;
+      prev_start = i;
+      i += r.num_chars;
+      find->y += r.baseline_y_delta;
+   }
+
+   find->first_char = first = i;
+   find->length = r.num_chars;
+   find->height = r.ymax - r.ymin;
+   find->prev_first = prev_start;
+
+   // now scan to find xpos
+   find->x = r.x0;
+   i = 0;
+   for (i=0; first+i < n; ++i)
+      find->x += STB_TEXTEDIT_GETWIDTH(str, first, i);
+}
+
+#define STB_TEXT_HAS_SELECTION(s)   ((s)->select_start != (s)->select_end)
+
+// make the selection/cursor state valid if client altered the string
+static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   int n = STB_TEXTEDIT_STRINGLEN(str);
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      if (state->select_start > n) state->select_start = n;
+      if (state->select_end   > n) state->select_end = n;
+      // if clamping forced them to be equal, move the cursor to match
+      if (state->select_start == state->select_end)
+         state->cursor = state->select_start;
+   }
+   if (state->cursor > n) state->cursor = n;
+}
+
+// delete characters while updating undo
+static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)
+{
+   stb_text_makeundo_delete(str, state, where, len);
+   STB_TEXTEDIT_DELETECHARS(str, where, len);
+   state->has_preferred_x = false;
+}
+
+// delete the section
+static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   stb_textedit_clamp(str, state);
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      if (state->select_start < state->select_end) {
+         stb_textedit_delete(str, state, state->select_start, state->select_end - state->select_start);
+         state->select_end = state->cursor = state->select_start;
+      } else {
+         stb_textedit_delete(str, state, state->select_end, state->select_start - state->select_end);
+         state->select_start = state->cursor = state->select_end;
+      }
+      state->has_preferred_x = false;
+   }
+}
+
+// canoncialize the selection so start <= end
+static void stb_textedit_sortselection(STB_TexteditState *state)
+{
+   if (state->select_end < state->select_start) {
+      int temp = state->select_end;
+      state->select_end = state->select_start;
+      state->select_start = temp;
+   }
+}
+
+// move cursor to first character of selection
+static void stb_textedit_move_to_first(STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      stb_textedit_sortselection(state);
+      state->cursor = state->select_start;
+      state->select_end = state->select_start;
+      state->has_preferred_x = false;
+   }
+}
+
+// move cursor to last character of selection
+static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      stb_textedit_sortselection(state);
+      stb_textedit_clamp(str, state);
+      state->cursor = state->select_end;
+      state->select_start = state->select_end;
+      state->has_preferred_x = false;
+   }
+}
+
+#ifdef STB_TEXTEDIT_IS_SPACE
+static rrbool is_word_boundary( STB_TEXTEDIT_STRING *_str, int _idx )
+{
+   RR_ASSERT( _idx < STB_TEXTEDIT_STRINGLEN(_str) );
+
+   return _idx > 0 ? (STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(_str,_idx-1) ) && !STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(_str, _idx) ) ) : true;
+}
+
+static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *_str, STB_TexteditState *_state )
+{
+   int c = _state->cursor - 1;
+   while( c >= 0 && !is_word_boundary( _str, c ) )
+      --c;
+
+   if( c < 0 )
+      c = 0;
+
+   return c;
+}
+
+static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *_str, STB_TexteditState *_state )
+{
+   const int len = STB_TEXTEDIT_STRINGLEN(_str);
+   int c = _state->cursor+1;
+   while( c < len && !is_word_boundary( _str, c ) )
+      ++c;
+
+   if( c > len )
+      c = len;
+
+   return c;
+}
+#endif
+
+// update selection and cursor to match each other
+static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)
+{
+   if (!STB_TEXT_HAS_SELECTION(state))
+      state->select_start = state->select_end = state->cursor;
+   else
+      state->cursor = state->select_end;
+}
+
+// API cut: delete selection
+static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      stb_textedit_delete_selection(str,state); // implicity clamps
+      state->has_preferred_x = false;
+      return 1;
+   }
+   return 0;
+}
+
+// API paste: replace existing selection with passed-in text
+static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)
+{
+   // if there's a selection, the paste should delete it
+   stb_textedit_clamp(str, state);
+   stb_textedit_delete_selection(str,state);
+   // try to insert the characters
+   if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len)) {
+      stb_text_makeundo_insert(str, state, state->cursor, len);
+      state->cursor += len;
+      state->has_preferred_x = false;
+      return 1;
+   }
+   // remove the undo since we didn't actually insert the characters
+   if (state->undostate.undo_point)
+      --state->undostate.undo_point;
+   return 0;
+}
+
+// API key: process a keyboard input
+static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int key)
+{
+retry:
+   switch (key) {
+      default: {
+         int c = STB_TEXTEDIT_KEYTOTEXT(key);
+         if (c > 0) {
+            STB_TEXTEDIT_CHARTYPE ch = (STB_TEXTEDIT_CHARTYPE) c;
+
+            // can't add newline in single-line mode
+            if (c == '\n' && state->single_line)
+               break;
+
+            if (state->insert_mode && !STB_TEXT_HAS_SELECTION(state) && state->cursor < STB_TEXTEDIT_STRINGLEN(str)) {
+               stb_text_makeundo_replace(str, state, state->cursor, 1, 1);
+               STB_TEXTEDIT_DELETECHARS(str, state->cursor, 1);
+               if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) {
+                  ++state->cursor;
+                  state->has_preferred_x = false;
+               }
+            } else {
+               stb_textedit_delete_selection(str,state); // implicity clamps
+               if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) {
+                  stb_text_makeundo_insert(str, state, state->cursor, 1);
+                  ++state->cursor;
+                  state->has_preferred_x = false;
+               }
+            }
+         }
+         break;
+      }
+
+#ifdef STB_TEXTEDIT_K_INSERT
+      case STB_TEXTEDIT_K_INSERT:
+         state->insert_mode = !state->insert_mode;
+         break;
+#endif
+         
+      case STB_TEXTEDIT_K_UNDO:
+         stb_text_undo(str, state);
+         state->has_preferred_x = false;
+         break;
+
+      case STB_TEXTEDIT_K_REDO:
+         stb_text_redo(str, state);
+         state->has_preferred_x = false;
+         break;
+
+      case STB_TEXTEDIT_K_LEFT:
+         // if currently there's a selection, move cursor to start of selection
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_first(state);
+         else 
+            if (state->cursor > 0)
+               --state->cursor;
+         state->has_preferred_x = false;
+         break;
+
+      case STB_TEXTEDIT_K_RIGHT:
+         // if currently there's a selection, move cursor to end of selection
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_last(str, state);
+         else
+            ++state->cursor;
+         stb_textedit_clamp(str, state);
+         state->has_preferred_x = false;
+         break;
+
+      case STB_TEXTEDIT_K_LEFT | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_clamp(str, state);
+         stb_textedit_prep_selection_at_cursor(state);
+         // move selection left
+         if (state->select_end > 0)
+            --state->select_end;
+         state->cursor = state->select_end;
+         state->has_preferred_x = false;
+         break;
+
+#ifdef STB_TEXTEDIT_IS_SPACE
+      case STB_TEXTEDIT_K_WORDLEFT:
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_first(state);
+         else {
+            state->cursor = stb_textedit_move_to_word_previous(str, state);
+            stb_textedit_clamp( str, state );
+         }
+         break;
+
+      case STB_TEXTEDIT_K_WORDRIGHT:
+         if (STB_TEXT_HAS_SELECTION(state)) 
+            stb_textedit_move_to_last(str, state);
+         else {
+            state->cursor = stb_textedit_move_to_word_next(str, state);
+            stb_textedit_clamp( str, state );
+         }
+         break;
+
+      case STB_TEXTEDIT_K_WORDLEFT | STB_TEXTEDIT_K_SHIFT:
+         if( !STB_TEXT_HAS_SELECTION( state ) )
+            stb_textedit_prep_selection_at_cursor(state);
+
+         state->cursor = stb_textedit_move_to_word_previous(str, state);
+         state->select_end = state->cursor;
+
+         stb_textedit_clamp( str, state );
+         break;
+
+      case STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT:
+         if( !STB_TEXT_HAS_SELECTION( state ) )
+            stb_textedit_prep_selection_at_cursor(state);
+
+         state->cursor = stb_textedit_move_to_word_next(str, state);
+         state->select_end = state->cursor;
+
+         stb_textedit_clamp( str, state );
+         break;
+#endif
+
+      case STB_TEXTEDIT_K_RIGHT | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_prep_selection_at_cursor(state);
+         // move selection right
+         ++state->select_end;
+         stb_textedit_clamp(str, state);
+         state->cursor = state->select_end;
+         state->has_preferred_x = false;
+         break;
+
+      case STB_TEXTEDIT_K_DOWN:
+      case STB_TEXTEDIT_K_DOWN | STB_TEXTEDIT_K_SHIFT: {
+         StbFindState find;
+         StbTexteditRow row;
+         int i, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
+
+         if (state->single_line) {
+            // on windows, up&down in single-line behave like left&right
+            key = STB_TEXTEDIT_K_RIGHT | (key & STB_TEXTEDIT_K_SHIFT);
+            goto retry;
+         }
+
+         if (sel)
+            stb_textedit_prep_selection_at_cursor(state);
+         else if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_last(str,state);
+
+         // compute current position of cursor point
+         stb_textedit_clamp(str, state);
+         stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+
+         // now find character position down a row
+         if (find.length) {
+            F32 goal_x = state->has_preferred_x ? state->preferred_x : find.x;
+            F32 x;
+            S32 start = find.first_char + find.length;
+            state->cursor = start;
+            STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
+            x = row.x0;
+            for (i=0; i < row.num_chars; ++i) {
+               F32 dx = STB_TEXTEDIT_GETWIDTH(str, start, i);
+               #ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE
+               if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE)
+                  break;
+               #endif
+               x += dx;
+               if (x > goal_x)
+                  break;
+               ++state->cursor;
+            }
+            stb_textedit_clamp(str, state);
+
+            state->has_preferred_x = true;
+            state->preferred_x = goal_x;
+
+            if (sel)
+               state->select_end = state->cursor;
+         }
+         break;
+      }
+         
+      case STB_TEXTEDIT_K_UP:
+      case STB_TEXTEDIT_K_UP | STB_TEXTEDIT_K_SHIFT: {
+         StbFindState find;
+         StbTexteditRow row;
+         int i, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
+
+         if (state->single_line) {
+            // on windows, up&down become left&right
+            key = STB_TEXTEDIT_K_LEFT | (key & STB_TEXTEDIT_K_SHIFT);
+            goto retry;
+         }
+
+         if (sel)
+            stb_textedit_prep_selection_at_cursor(state);
+         else if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_first(state);
+
+         // compute current position of cursor point
+         stb_textedit_clamp(str, state);
+         stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+
+         // can only go up if there's a previous row
+         if (find.prev_first != find.first_char) {
+            // now find character position up a row
+            F32 goal_x = state->has_preferred_x ? state->preferred_x : find.x;
+            F32 x;
+            state->cursor = find.prev_first;
+            STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
+            x = row.x0;
+            for (i=0; i < row.num_chars; ++i) {
+               F32 dx = STB_TEXTEDIT_GETWIDTH(str, find.prev_first, i);
+               #ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE
+               if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE)
+                  break;
+               #endif
+               x += dx;
+               if (x > goal_x)
+                  break;
+               ++state->cursor;
+            }
+            stb_textedit_clamp(str, state);
+
+            state->has_preferred_x = true;
+            state->preferred_x = goal_x;
+
+            if (sel)
+               state->select_end = state->cursor;
+         }
+         break;
+      }
+
+      case STB_TEXTEDIT_K_DELETE:
+      case STB_TEXTEDIT_K_DELETE | STB_TEXTEDIT_K_SHIFT:
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_delete_selection(str, state);
+         else {
+            int n = STB_TEXTEDIT_STRINGLEN(str);
+            if (state->cursor < n)
+               stb_textedit_delete(str, state, state->cursor, 1);
+         }
+         state->has_preferred_x = false;
+         break;
+
+      case STB_TEXTEDIT_K_BACKSPACE:
+      case STB_TEXTEDIT_K_BACKSPACE | STB_TEXTEDIT_K_SHIFT:
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_delete_selection(str, state);
+         else {
+            stb_textedit_clamp(str, state);
+            if (state->cursor > 0) {
+               stb_textedit_delete(str, state, state->cursor-1, 1);
+               --state->cursor;
+            }
+         }
+         state->has_preferred_x = false;
+         break;
+         
+      case STB_TEXTEDIT_K_TEXTSTART:
+         state->cursor = state->select_start = state->select_end = 0;
+         state->has_preferred_x = false;
+         break;
+
+      case STB_TEXTEDIT_K_TEXTEND:
+         state->cursor = STB_TEXTEDIT_STRINGLEN(str);
+         state->select_start = state->select_end = 0;
+         state->has_preferred_x = false;
+         break;
+        
+      case STB_TEXTEDIT_K_TEXTSTART | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_prep_selection_at_cursor(state);
+         state->cursor = state->select_end = 0;
+         state->has_preferred_x = false;
+         break;
+
+      case STB_TEXTEDIT_K_TEXTEND | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_prep_selection_at_cursor(state);
+         state->cursor = state->select_end = STB_TEXTEDIT_STRINGLEN(str);
+         state->has_preferred_x = false;
+         break;
+
+
+      case STB_TEXTEDIT_K_LINESTART: {
+         StbFindState find;
+         stb_textedit_clamp(str, state);
+         stb_textedit_move_to_first(state);
+         stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+         state->cursor = find.first_char;
+         state->has_preferred_x = false;
+         break;
+      }
+
+      case STB_TEXTEDIT_K_LINEEND: {
+         StbFindState find;
+         stb_textedit_clamp(str, state);
+         stb_textedit_move_to_first(state);
+         stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+         state->cursor = find.first_char + find.length;
+         state->has_preferred_x = false;
+         break;
+      }
+
+      case STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT: {
+         StbFindState find;
+         stb_textedit_clamp(str, state);
+         stb_textedit_prep_selection_at_cursor(state);
+         stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+         state->select_end = find.first_char;
+         state->has_preferred_x = false;
+         break;
+      }
+
+      case STB_TEXTEDIT_K_LINEEND | STB_TEXTEDIT_K_SHIFT: {
+         StbFindState find;
+         stb_textedit_clamp(str, state);
+         stb_textedit_prep_selection_at_cursor(state);
+         stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+         state->select_end = find.first_char + find.length;
+         state->has_preferred_x = false;
+         break;
+      }
+
+// @TODO:
+//    STB_TEXTEDIT_K_PGUP      - move cursor up a page
+//    STB_TEXTEDIT_K_PGDOWN    - move cursor down a page
+   }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Undo processing
+//
+// @OPTIMIZE: the undo/redo buffer should be circular
+
+static void stb_textedit_flush_redo(StbUndoState *state)
+{
+   state->redo_point = STB_TEXTEDIT_UNDOSTATECOUNT;
+   state->redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT;
+}
+
+// discard the oldest entry in the undo list
+static void stb_textedit_discard_undo(StbUndoState *state)
+{
+   if (state->undo_point > 0) {
+      // if the 0th undo state has characters, clean those up
+      if (state->undo_rec[0].char_storage >= 0) {
+         int n = state->undo_rec[0].insert_length, i;
+         // delete n characters from all other records
+         state->undo_char_point = state->undo_char_point - (short) n;  // vsnet05
+         memmove(state->undo_char, state->undo_char + n, state->undo_char_point*sizeof(STB_TEXTEDIT_CHARTYPE));
+         for (i=0; i < state->undo_point; ++i)
+            if (state->undo_rec[i].char_storage >= 0)
+               state->undo_rec[i].char_storage = state->undo_rec[i].char_storage - (short) n; // vsnet05 // @OPTIMIZE: get rid of char_storage and infer it
+      }
+      --state->undo_point;
+      memmove(state->undo_rec, state->undo_rec+1, state->undo_point*sizeof(state->undo_rec[0]));
+   }
+}
+
+// discard the oldest entry in the redo list--it's bad if this
+// ever happens, but because undo & redo have to store the actual
+// characters in different cases, the redo character buffer can
+// fill up even though the undo buffer didn't
+static void stb_textedit_discard_redo(StbUndoState *state)
+{
+   int k = STB_TEXTEDIT_UNDOSTATECOUNT-1;
+
+   if (state->redo_point <= k) {
+      // if the k'th undo state has characters, clean those up
+      if (state->undo_rec[k].char_storage >= 0) {
+         int n = state->undo_rec[k].insert_length, i;
+         // delete n characters from all other records
+         state->redo_char_point = state->redo_char_point + (short) n; // vsnet05
+         memmove(state->undo_char + state->redo_char_point, state->undo_char + state->redo_char_point-n, (STB_TEXTEDIT_UNDOSTATECOUNT - state->redo_char_point)*sizeof(STB_TEXTEDIT_CHARTYPE));
+         for (i=state->redo_point; i < k; ++i)
+            if (state->undo_rec[i].char_storage >= 0)
+               state->undo_rec[i].char_storage = state->undo_rec[i].char_storage + (short) n; // vsnet05
+      }
+      ++state->redo_point;
+      memmove(state->undo_rec + state->redo_point-1, state->undo_rec + state->redo_point, (STB_TEXTEDIT_UNDOSTATECOUNT - state->redo_point)*sizeof(state->undo_rec[0]));
+   }
+}
+
+static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)
+{
+   // any time we create a new undo record, we discard redo
+   stb_textedit_flush_redo(state);
+
+   // if we have no free records, we have to make room, by sliding the
+   // existing records down
+   if (state->undo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+      stb_textedit_discard_undo(state);
+
+   // if the characters to store won't possibly fit in the buffer, we can't undo
+   if (numchars > STB_TEXTEDIT_UNDOCHARCOUNT) {
+      state->undo_point = 0;
+      state->undo_char_point = 0;
+      return NULL;
+   }
+
+   // if we don't have enough free characters in the buffer, we have to make room
+   while (state->undo_char_point + numchars > STB_TEXTEDIT_UNDOCHARCOUNT)
+      stb_textedit_discard_undo(state);
+
+   return &state->undo_rec[state->undo_point++];
+}
+
+static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
+{
+   StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
+   if (r == NULL)
+      return NULL;
+
+   r->where = pos;
+   r->insert_length = (short) insert_len;
+   r->delete_length = (short) delete_len;
+
+   if (insert_len == 0) {
+      r->char_storage = -1;
+      return NULL;
+   } else {
+      r->char_storage = state->undo_char_point;
+      state->undo_char_point = state->undo_char_point + (short) insert_len;
+      return &state->undo_char[r->char_storage];
+   }
+}
+
+static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   StbUndoState *s = &state->undostate;
+   StbUndoRecord u, *r;
+   if (s->undo_point == 0)
+      return;
+
+   // we need to do two things: apply the undo record, and create a redo record
+   u = s->undo_rec[s->undo_point-1];
+   r = &s->undo_rec[s->redo_point-1];
+   r->char_storage = -1;
+
+   r->insert_length = u.delete_length;
+   r->delete_length = u.insert_length;
+   r->where = u.where;
+
+   if (u.delete_length) {
+      // if the undo record says to delete characters, then the redo record will
+      // need to re-insert the characters that get deleted, so we need to store
+      // them.
+
+      // there are three cases:
+      //    there's enough room to store the characters
+      //    characters stored for *redoing* don't leave room for redo
+      //    characters stored for *undoing* don't leave room for redo
+      // if the last is true, we have to bail
+
+      if (s->undo_char_point + u.delete_length >= STB_TEXTEDIT_UNDOCHARCOUNT) {
+         // the undo records take up too much character space; there's no space to store the redo characters
+         r->insert_length = 0;
+      } else {
+         int i;
+
+         // there's definitely room to store the characters eventually
+         while (s->undo_char_point + u.delete_length > s->redo_char_point) {
+            // there's currently not enough room, so discard a redo record
+            stb_textedit_discard_redo(s);
+            // should never happen:
+            if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+               return;
+         }
+         r = &s->undo_rec[s->redo_point-1];
+
+         r->char_storage = s->redo_char_point - u.delete_length;
+         s->redo_char_point = s->redo_char_point - (short) u.delete_length;
+
+         // now save the characters
+         for (i=0; i < u.delete_length; ++i)
+            s->undo_char[r->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u.where + i);
+      }
+
+      // now we can carry out the deletion
+      STB_TEXTEDIT_DELETECHARS(str, u.where, u.delete_length);
+   }
+
+   // check type of recorded action:
+   if (u.insert_length) {
+      // easy case: was a deletion, so we need to insert n characters
+      STB_TEXTEDIT_INSERTCHARS(str, u.where, &s->undo_char[u.char_storage], u.insert_length);
+      s->undo_char_point -= u.insert_length;
+   }
+
+   state->cursor = u.where + u.insert_length;
+
+   s->undo_point--;
+   s->redo_point--;
+}
+
+static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   StbUndoState *s = &state->undostate;
+   StbUndoRecord *u, r;
+   if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+      return;
+
+   // we need to do two things: apply the redo record, and create an undo record
+   u = &s->undo_rec[s->undo_point];
+   r = s->undo_rec[s->redo_point];
+
+   // we KNOW there must be room for the undo record, because the redo record
+   // was derived from an undo record
+
+   u->delete_length = r.insert_length;
+   u->insert_length = r.delete_length;
+   u->where = r.where;
+   u->char_storage = -1;
+
+   if (r.delete_length) {
+      // the redo record requires us to delete characters, so the undo record
+      // needs to store the characters
+
+      if (s->undo_char_point + u->insert_length > s->redo_char_point) {
+         u->insert_length = 0;
+         u->delete_length = 0;
+      } else {
+         int i;
+         u->char_storage = s->undo_char_point;
+         s->undo_char_point = s->undo_char_point + u->insert_length;
+
+         // now save the characters
+         for (i=0; i < u->insert_length; ++i)
+            s->undo_char[u->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u->where + i);
+      }
+
+      STB_TEXTEDIT_DELETECHARS(str, r.where, r.delete_length);
+   }
+
+   if (r.insert_length) {
+      // easy case: need to insert n characters
+      STB_TEXTEDIT_INSERTCHARS(str, r.where, &s->undo_char[r.char_storage], r.insert_length);
+   }
+
+   state->cursor = r.where + r.insert_length;
+
+   s->undo_point++;
+   s->redo_point++;
+}
+
+static void stb_text_makeundo_insert(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)
+{
+   stb_text_createundo(&state->undostate, where, 0, length);
+}
+
+static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)
+{
+   int i;
+   STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, length, 0);
+   if (p) {
+      for (i=0; i < length; ++i)
+         p[i] = STB_TEXTEDIT_GETCHAR(str, where+i);
+   }
+}
+
+static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)
+{
+   int i;
+   STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, old_length, new_length);
+   if (p) {
+      for (i=0; i < old_length; ++i)
+         p[i] = STB_TEXTEDIT_GETCHAR(str, where+i);
+   }
+}
+
+// reset the state to default
+static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)
+{
+   state->undostate.undo_point = 0;
+   state->undostate.undo_char_point = 0;
+   state->undostate.redo_point = STB_TEXTEDIT_UNDOSTATECOUNT;
+   state->undostate.redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT;
+   state->select_end = state->select_start = 0;
+   state->cursor = 0;
+   state->has_preferred_x = 0;
+   state->preferred_x = 0;
+   state->cursor_at_end_of_line = 0;
+   state->initialized = 1;
+   state->single_line = (unsigned char) is_single_line;
+   state->insert_mode = 0;
+}
+
+// API initialize
+static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
+{
+   stb_textedit_clear_state(state, is_single_line);
+}
+#endif//STB_TEXTEDIT_IMPLEMENTATION

stb_vorbis.c

@@ -0,0 +1,5370 @@
+// Ogg Vorbis I audio decoder  -- version 0.99996
+//
+// Written in April 2007 by Sean Barrett, sponsored by RAD Game Tools.
+//
+// Placed in the public domain April 2007 by the author: no copyright is
+// claimed, and you may use it for any purpose you like.
+//
+// No warranty for any purpose is expressed or implied by the author (nor
+// by RAD Game Tools). Report bugs and send enhancements to the author.
+//
+// Get the latest version and other information at:
+//     http://nothings.org/stb_vorbis/
+
+
+// Todo:
+//
+//   - seeking (note you can seek yourself using the pushdata API)
+//
+// Limitations:
+//
+//   - floor 0 not supported (used in old ogg vorbis files)
+//   - lossless sample-truncation at beginning ignored
+//   - cannot concatenate multiple vorbis streams
+//   - sample positions are 32-bit, limiting seekable 192Khz
+//       files to around 6 hours (Ogg supports 64-bit)
+// 
+// All of these limitations may be removed in future versions.
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  HEADER BEGINS HERE
+//
+
+#ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H
+#define STB_VORBIS_INCLUDE_STB_VORBIS_H
+
+#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
+#define STB_VORBIS_NO_STDIO 1
+#endif
+
+#ifndef STB_VORBIS_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////   THREAD SAFETY
+
+// Individual stb_vorbis* handles are not thread-safe; you cannot decode from
+// them from multiple threads at the same time. However, you can have multiple
+// stb_vorbis* handles and decode from them independently in multiple thrads.
+
+
+///////////   MEMORY ALLOCATION
+
+// normally stb_vorbis uses malloc() to allocate memory at startup,
+// and alloca() to allocate temporary memory during a frame on the
+// stack. (Memory consumption will depend on the amount of setup
+// data in the file and how you set the compile flags for speed
+// vs. size. In my test files the maximal-size usage is ~150KB.)
+//
+// You can modify the wrapper functions in the source (setup_malloc,
+// setup_temp_malloc, temp_malloc) to change this behavior, or you
+// can use a simpler allocation model: you pass in a buffer from
+// which stb_vorbis will allocate _all_ its memory (including the
+// temp memory). "open" may fail with a VORBIS_outofmem if you
+// do not pass in enough data; there is no way to determine how
+// much you do need except to succeed (at which point you can
+// query get_info to find the exact amount required. yes I know
+// this is lame).
+//
+// If you pass in a non-NULL buffer of the type below, allocation
+// will occur from it as described above. Otherwise just pass NULL
+// to use malloc()/alloca()
+
+typedef struct
+{
+   char *alloc_buffer;
+   int   alloc_buffer_length_in_bytes;
+} stb_vorbis_alloc;
+
+
+///////////   FUNCTIONS USEABLE WITH ALL INPUT MODES
+
+typedef struct stb_vorbis stb_vorbis;
+
+typedef struct
+{
+   unsigned int sample_rate;
+   int channels;
+
+   unsigned int setup_memory_required;
+   unsigned int setup_temp_memory_required;
+   unsigned int temp_memory_required;
+
+   int max_frame_size;
+} stb_vorbis_info;
+
+// get general information about the file
+extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f);
+
+// get the last error detected (clears it, too)
+extern int stb_vorbis_get_error(stb_vorbis *f);
+
+// close an ogg vorbis file and free all memory in use
+extern void stb_vorbis_close(stb_vorbis *f);
+
+// this function returns the offset (in samples) from the beginning of the
+// file that will be returned by the next decode, if it is known, or -1
+// otherwise. after a flush_pushdata() call, this may take a while before
+// it becomes valid again.
+// NOT WORKING YET after a seek with PULLDATA API
+extern int stb_vorbis_get_sample_offset(stb_vorbis *f);
+
+// returns the current seek point within the file, or offset from the beginning
+// of the memory buffer. In pushdata mode it returns 0.
+extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f);
+
+///////////   PUSHDATA API
+
+#ifndef STB_VORBIS_NO_PUSHDATA_API
+
+// this API allows you to get blocks of data from any source and hand
+// them to stb_vorbis. you have to buffer them; stb_vorbis will tell
+// you how much it used, and you have to give it the rest next time;
+// and stb_vorbis may not have enough data to work with and you will
+// need to give it the same data again PLUS more. Note that the Vorbis
+// specification does not bound the size of an individual frame.
+
+extern stb_vorbis *stb_vorbis_open_pushdata(
+         unsigned char *datablock, int datablock_length_in_bytes,
+         int *datablock_memory_consumed_in_bytes,
+         int *error,
+         stb_vorbis_alloc *alloc_buffer);
+// create a vorbis decoder by passing in the initial data block containing
+//    the ogg&vorbis headers (you don't need to do parse them, just provide
+//    the first N bytes of the file--you're told if it's not enough, see below)
+// on success, returns an stb_vorbis *, does not set error, returns the amount of
+//    data parsed/consumed on this call in *datablock_memory_consumed_in_bytes;
+// on failure, returns NULL on error and sets *error, does not change *datablock_memory_consumed
+// if returns NULL and *error is VORBIS_need_more_data, then the input block was
+//       incomplete and you need to pass in a larger block from the start of the file
+
+extern int stb_vorbis_decode_frame_pushdata(
+         stb_vorbis *f, unsigned char *datablock, int datablock_length_in_bytes,
+         int *channels,             // place to write number of float * buffers
+         float ***output,           // place to write float ** array of float * buffers
+         int *samples               // place to write number of output samples
+     );
+// decode a frame of audio sample data if possible from the passed-in data block
+//
+// return value: number of bytes we used from datablock
+// possible cases:
+//     0 bytes used, 0 samples output (need more data)
+//     N bytes used, 0 samples output (resynching the stream, keep going)
+//     N bytes used, M samples output (one frame of data)
+// note that after opening a file, you will ALWAYS get one N-bytes,0-sample
+// frame, because Vorbis always "discards" the first frame.
+//
+// Note that on resynch, stb_vorbis will rarely consume all of the buffer,
+// instead only datablock_length_in_bytes-3 or less. This is because it wants
+// to avoid missing parts of a page header if they cross a datablock boundary,
+// without writing state-machiney code to record a partial detection.
+//
+// The number of channels returned are stored in *channels (which can be
+// NULL--it is always the same as the number of channels reported by
+// get_info). *output will contain an array of float* buffers, one per
+// channel. In other words, (*output)[0][0] contains the first sample from
+// the first channel, and (*output)[1][0] contains the first sample from
+// the second channel.
+
+extern void stb_vorbis_flush_pushdata(stb_vorbis *f);
+// inform stb_vorbis that your next datablock will not be contiguous with
+// previous ones (e.g. you've seeked in the data); future attempts to decode
+// frames will cause stb_vorbis to resynchronize (as noted above), and
+// once it sees a valid Ogg page (typically 4-8KB, as large as 64KB), it
+// will begin decoding the _next_ frame.
+//
+// if you want to seek using pushdata, you need to seek in your file, then
+// call stb_vorbis_flush_pushdata(), then start calling decoding, then once
+// decoding is returning you data, call stb_vorbis_get_sample_offset, and
+// if you don't like the result, seek your file again and repeat.
+#endif
+
+
+//////////   PULLING INPUT API
+
+#ifndef STB_VORBIS_NO_PULLDATA_API
+// This API assumes stb_vorbis is allowed to pull data from a source--
+// either a block of memory containing the _entire_ vorbis stream, or a
+// FILE * that you or it create, or possibly some other reading mechanism
+// if you go modify the source to replace the FILE * case with some kind
+// of callback to your code. (But if you don't support seeking, you may
+// just want to go ahead and use pushdata.)
+
+#if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
+extern int stb_vorbis_decode_filename(char *filename, int *channels, short **output);
+#endif
+extern int stb_vorbis_decode_memory(unsigned char *mem, int len, int *channels, short **output);
+// decode an entire file and output the data interleaved into a malloc()ed
+// buffer stored in *output. The return value is the number of samples
+// decoded, or -1 if the file could not be opened or was not an ogg vorbis file.
+// When you're done with it, just free() the pointer returned in *output.
+
+extern stb_vorbis * stb_vorbis_open_memory(unsigned char *data, int len,
+                                  int *error, stb_vorbis_alloc *alloc_buffer);
+// create an ogg vorbis decoder from an ogg vorbis stream in memory (note
+// this must be the entire stream!). on failure, returns NULL and sets *error
+
+#ifndef STB_VORBIS_NO_STDIO
+extern stb_vorbis * stb_vorbis_open_filename(char *filename,
+                                  int *error, stb_vorbis_alloc *alloc_buffer);
+// create an ogg vorbis decoder from a filename via fopen(). on failure,
+// returns NULL and sets *error (possibly to VORBIS_file_open_failure).
+
+extern stb_vorbis * stb_vorbis_open_file(FILE *f, int close_handle_on_close,
+                                  int *error, stb_vorbis_alloc *alloc_buffer);
+// create an ogg vorbis decoder from an open FILE *, looking for a stream at
+// the _current_ seek point (ftell). on failure, returns NULL and sets *error.
+// note that stb_vorbis must "own" this stream; if you seek it in between
+// calls to stb_vorbis, it will become confused. Morever, if you attempt to
+// perform stb_vorbis_seek_*() operations on this file, it will assume it
+// owns the _entire_ rest of the file after the start point. Use the next
+// function, stb_vorbis_open_file_section(), to limit it.
+
+extern stb_vorbis * stb_vorbis_open_file_section(FILE *f, int close_handle_on_close,
+                int *error, stb_vorbis_alloc *alloc_buffer, unsigned int len);
+// create an ogg vorbis decoder from an open FILE *, looking for a stream at
+// the _current_ seek point (ftell); the stream will be of length 'len' bytes.
+// on failure, returns NULL and sets *error. note that stb_vorbis must "own"
+// this stream; if you seek it in between calls to stb_vorbis, it will become
+// confused.
+#endif
+
+extern int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number);
+extern int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number);
+// NOT WORKING YET
+// these functions seek in the Vorbis file to (approximately) 'sample_number'.
+// after calling seek_frame(), the next call to get_frame_*() will include
+// the specified sample. after calling stb_vorbis_seek(), the next call to
+// stb_vorbis_get_samples_* will start with the specified sample. If you
+// do not need to seek to EXACTLY the target sample when using get_samples_*,
+// you can also use seek_frame().
+
+extern void stb_vorbis_seek_start(stb_vorbis *f);
+// this function is equivalent to stb_vorbis_seek(f,0), but it
+// actually works
+
+extern unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f);
+extern float        stb_vorbis_stream_length_in_seconds(stb_vorbis *f);
+// these functions return the total length of the vorbis stream
+
+extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output);
+// decode the next frame and return the number of samples. the number of
+// channels returned are stored in *channels (which can be NULL--it is always
+// the same as the number of channels reported by get_info). *output will
+// contain an array of float* buffers, one per channel. These outputs will
+// be overwritten on the next call to stb_vorbis_get_frame_*.
+//
+// You generally should not intermix calls to stb_vorbis_get_frame_*()
+// and stb_vorbis_get_samples_*(), since the latter calls the former.
+
+#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
+extern int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts);
+extern int stb_vorbis_get_frame_short            (stb_vorbis *f, int num_c, short **buffer, int num_samples);
+#endif
+// decode the next frame and return the number of samples per channel. the
+// data is coerced to the number of channels you request according to the
+// channel coercion rules (see below). You must pass in the size of your
+// buffer(s) so that stb_vorbis will not overwrite the end of the buffer.
+// The maximum buffer size needed can be gotten from get_info(); however,
+// the Vorbis I specification implies an absolute maximum of 4096 samples
+// per channel. Note that for interleaved data, you pass in the number of
+// shorts (the size of your array), but the return value is the number of
+// samples per channel, not the total number of samples.
+
+// Channel coercion rules:
+//    Let M be the number of channels requested, and N the number of channels present,
+//    and Cn be the nth channel; let stereo L be the sum of all L and center channels,
+//    and stereo R be the sum of all R and center channels (channel assignment from the
+//    vorbis spec).
+//        M    N       output
+//        1    k      sum(Ck) for all k
+//        2    *      stereo L, stereo R
+//        k    l      k > l, the first l channels, then 0s
+//        k    l      k <= l, the first k channels
+//    Note that this is not _good_ surround etc. mixing at all! It's just so
+//    you get something useful.
+
+extern int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats);
+extern int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples);
+// gets num_samples samples, not necessarily on a frame boundary--this requires
+// buffering so you have to supply the buffers. DOES NOT APPLY THE COERCION RULES.
+// Returns the number of samples stored per channel; it may be less than requested
+// at the end of the file. If there are no more samples in the file, returns 0.
+
+#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
+extern int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts);
+extern int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int num_samples);
+#endif
+// gets num_samples samples, not necessarily on a frame boundary--this requires
+// buffering so you have to supply the buffers. Applies the coercion rules above
+// to produce 'channels' channels. Returns the number of samples stored per channel;
+// it may be less than requested at the end of the file. If there are no more
+// samples in the file, returns 0.
+
+#endif
+
+////////   ERROR CODES
+
+enum STBVorbisError
+{
+   VORBIS__no_error,
+
+   VORBIS_need_more_data=1,             // not a real error
+
+   VORBIS_invalid_api_mixing,           // can't mix API modes
+   VORBIS_outofmem,                     // not enough memory
+   VORBIS_feature_not_supported,        // uses floor 0
+   VORBIS_too_many_channels,            // STB_VORBIS_MAX_CHANNELS is too small
+   VORBIS_file_open_failure,            // fopen() failed
+   VORBIS_seek_without_length,          // can't seek in unknown-length file
+
+   VORBIS_unexpected_eof=10,            // file is truncated?
+   VORBIS_seek_invalid,                 // seek past EOF
+
+   // decoding errors (corrupt/invalid stream) -- you probably
+   // don't care about the exact details of these
+
+   // vorbis errors:
+   VORBIS_invalid_setup=20,
+   VORBIS_invalid_stream,
+
+   // ogg errors:
+   VORBIS_missing_capture_pattern=30,
+   VORBIS_invalid_stream_structure_version,
+   VORBIS_continued_packet_flag_invalid,
+   VORBIS_incorrect_stream_serial_number,
+   VORBIS_invalid_first_page,
+   VORBIS_bad_packet_type,
+   VORBIS_cant_find_last_page,
+   VORBIS_seek_failed,
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // STB_VORBIS_INCLUDE_STB_VORBIS_H
+//
+//  HEADER ENDS HERE
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef STB_VORBIS_HEADER_ONLY
+
+// global configuration settings (e.g. set these in the project/makefile),
+// or just set them in this file at the top (although ideally the first few
+// should be visible when the header file is compiled too, although it's not
+// crucial)
+
+// STB_VORBIS_NO_PUSHDATA_API
+//     does not compile the code for the various stb_vorbis_*_pushdata()
+//     functions
+// #define STB_VORBIS_NO_PUSHDATA_API
+
+// STB_VORBIS_NO_PULLDATA_API
+//     does not compile the code for the non-pushdata APIs
+// #define STB_VORBIS_NO_PULLDATA_API
+
+// STB_VORBIS_NO_STDIO
+//     does not compile the code for the APIs that use FILE *s internally
+//     or externally (implied by STB_VORBIS_NO_PULLDATA_API)
+// #define STB_VORBIS_NO_STDIO
+
+// STB_VORBIS_NO_INTEGER_CONVERSION
+//     does not compile the code for converting audio sample data from
+//     float to integer (implied by STB_VORBIS_NO_PULLDATA_API)
+// #define STB_VORBIS_NO_INTEGER_CONVERSION
+
+// STB_VORBIS_NO_FAST_SCALED_FLOAT
+//      does not use a fast float-to-int trick to accelerate float-to-int on
+//      most platforms which requires endianness be defined correctly.
+//#define STB_VORBIS_NO_FAST_SCALED_FLOAT
+
+
+// STB_VORBIS_MAX_CHANNELS [number]
+//     globally define this to the maximum number of channels you need.
+//     The spec does not put a restriction on channels except that
+//     the count is stored in a byte, so 255 is the hard limit.
+//     Reducing this saves about 16 bytes per value, so using 16 saves
+//     (255-16)*16 or around 4KB. Plus anything other memory usage
+//     I forgot to account for. Can probably go as low as 8 (7.1 audio),
+//     6 (5.1 audio), or 2 (stereo only).
+#ifndef STB_VORBIS_MAX_CHANNELS
+#define STB_VORBIS_MAX_CHANNELS    16  // enough for anyone?
+#endif
+
+// STB_VORBIS_PUSHDATA_CRC_COUNT [number]
+//     after a flush_pushdata(), stb_vorbis begins scanning for the
+//     next valid page, without backtracking. when it finds something
+//     that looks like a page, it streams through it and verifies its
+//     CRC32. Should that validation fail, it keeps scanning. But it's
+//     possible that _while_ streaming through to check the CRC32 of
+//     one candidate page, it sees another candidate page. This #define
+//     determines how many "overlapping" candidate pages it can search
+//     at once. Note that "real" pages are typically ~4KB to ~8KB, whereas
+//     garbage pages could be as big as 64KB, but probably average ~16KB.
+//     So don't hose ourselves by scanning an apparent 64KB page and
+//     missing a ton of real ones in the interim; so minimum of 2
+#ifndef STB_VORBIS_PUSHDATA_CRC_COUNT
+#define STB_VORBIS_PUSHDATA_CRC_COUNT  4
+#endif
+
+// STB_VORBIS_FAST_HUFFMAN_LENGTH [number]
+//     sets the log size of the huffman-acceleration table.  Maximum
+//     supported value is 24. with larger numbers, more decodings are O(1),
+//     but the table size is larger so worse cache missing, so you'll have
+//     to probe (and try multiple ogg vorbis files) to find the sweet spot.
+#ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH
+#define STB_VORBIS_FAST_HUFFMAN_LENGTH   10
+#endif
+
+// STB_VORBIS_FAST_BINARY_LENGTH [number]
+//     sets the log size of the binary-search acceleration table. this
+//     is used in similar fashion to the fast-huffman size to set initial
+//     parameters for the binary search
+
+// STB_VORBIS_FAST_HUFFMAN_INT
+//     The fast huffman tables are much more efficient if they can be
+//     stored as 16-bit results instead of 32-bit results. This restricts
+//     the codebooks to having only 65535 possible outcomes, though.
+//     (At least, accelerated by the huffman table.)
+#ifndef STB_VORBIS_FAST_HUFFMAN_INT
+#define STB_VORBIS_FAST_HUFFMAN_SHORT
+#endif
+
+// STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH
+//     If the 'fast huffman' search doesn't succeed, then stb_vorbis falls
+//     back on binary searching for the correct one. This requires storing
+//     extra tables with the huffman codes in sorted order. Defining this
+//     symbol trades off space for speed by forcing a linear search in the
+//     non-fast case, except for "sparse" codebooks.
+// #define STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH
+
+// STB_VORBIS_DIVIDES_IN_RESIDUE
+//     stb_vorbis precomputes the result of the scalar residue decoding
+//     that would otherwise require a divide per chunk. you can trade off
+//     space for time by defining this symbol.
+// #define STB_VORBIS_DIVIDES_IN_RESIDUE
+
+// STB_VORBIS_DIVIDES_IN_CODEBOOK
+//     vorbis VQ codebooks can be encoded two ways: with every case explicitly
+//     stored, or with all elements being chosen from a small range of values,
+//     and all values possible in all elements. By default, stb_vorbis expands
+//     this latter kind out to look like the former kind for ease of decoding,
+//     because otherwise an integer divide-per-vector-element is required to
+//     unpack the index. If you define STB_VORBIS_DIVIDES_IN_CODEBOOK, you can
+//     trade off storage for speed.
+//#define STB_VORBIS_DIVIDES_IN_CODEBOOK
+
+// STB_VORBIS_CODEBOOK_SHORTS
+//     The vorbis file format encodes VQ codebook floats as ax+b where a and
+//     b are floating point per-codebook constants, and x is a 16-bit int.
+//     Normally, stb_vorbis decodes them to floats rather than leaving them
+//     as 16-bit ints and computing ax+b while decoding. This is a speed/space
+//     tradeoff; you can save space by defining this flag.
+#ifndef STB_VORBIS_CODEBOOK_SHORTS
+#define STB_VORBIS_CODEBOOK_FLOATS
+#endif
+
+// STB_VORBIS_DIVIDE_TABLE
+//     this replaces small integer divides in the floor decode loop with
+//     table lookups. made less than 1% difference, so disabled by default.
+
+// STB_VORBIS_NO_INLINE_DECODE
+//     disables the inlining of the scalar codebook fast-huffman decode.
+//     might save a little codespace; useful for debugging
+// #define STB_VORBIS_NO_INLINE_DECODE
+
+// STB_VORBIS_NO_DEFER_FLOOR
+//     Normally we only decode the floor without synthesizing the actual
+//     full curve. We can instead synthesize the curve immediately. This
+//     requires more memory and is very likely slower, so I don't think
+//     you'd ever want to do it except for debugging.
+// #define STB_VORBIS_NO_DEFER_FLOOR
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef STB_VORBIS_NO_PULLDATA_API
+   #define STB_VORBIS_NO_INTEGER_CONVERSION
+   #define STB_VORBIS_NO_STDIO
+#endif
+
+#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
+   #define STB_VORBIS_NO_STDIO 1
+#endif
+
+#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
+#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT
+
+   // only need endianness for fast-float-to-int, which we don't
+   // use for pushdata
+
+   #ifndef STB_VORBIS_BIG_ENDIAN
+     #define STB_VORBIS_ENDIAN  0
+   #else
+     #define STB_VORBIS_ENDIAN  1
+   #endif
+
+#endif
+#endif
+
+
+#ifndef STB_VORBIS_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STB_VORBIS_NO_CRT
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+#if !(defined(__APPLE__) || defined(MACOSX) || defined(macintosh) || defined(Macintosh))
+#include <malloc.h>
+#endif
+#else
+#define NULL 0
+#endif
+
+#ifndef _MSC_VER
+   #if __GNUC__
+      #define __forceinline inline
+   #else
+      #define __forceinline
+   #endif
+#endif
+
+#if STB_VORBIS_MAX_CHANNELS > 256
+#error "Value of STB_VORBIS_MAX_CHANNELS outside of allowed range"
+#endif
+
+#if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24
+#error "Value of STB_VORBIS_FAST_HUFFMAN_LENGTH outside of allowed range"
+#endif
+
+
+#define MAX_BLOCKSIZE_LOG  13   // from specification
+#define MAX_BLOCKSIZE      (1 << MAX_BLOCKSIZE_LOG)
+
+
+typedef unsigned char  uint8;
+typedef   signed char   int8;
+typedef unsigned short uint16;
+typedef   signed short  int16;
+typedef unsigned int   uint32;
+typedef   signed int    int32;
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+#ifdef STB_VORBIS_CODEBOOK_FLOATS
+typedef float codetype;
+#else
+typedef uint16 codetype;
+#endif
+
+// @NOTE
+//
+// Some arrays below are tagged "//varies", which means it's actually
+// a variable-sized piece of data, but rather than malloc I assume it's
+// small enough it's better to just allocate it all together with the
+// main thing
+//
+// Most of the variables are specified with the smallest size I could pack
+// them into. It might give better performance to make them all full-sized
+// integers. It should be safe to freely rearrange the structures or change
+// the sizes larger--nothing relies on silently truncating etc., nor the
+// order of variables.
+
+#define FAST_HUFFMAN_TABLE_SIZE   (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH)
+#define FAST_HUFFMAN_TABLE_MASK   (FAST_HUFFMAN_TABLE_SIZE - 1)
+
+typedef struct
+{
+   int dimensions, entries;
+   uint8 *codeword_lengths;
+   float  minimum_value;
+   float  delta_value;
+   uint8  value_bits;
+   uint8  lookup_type;
+   uint8  sequence_p;
+   uint8  sparse;
+   uint32 lookup_values;
+   codetype *multiplicands;
+   uint32 *codewords;
+   #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT
+    int16  fast_huffman[FAST_HUFFMAN_TABLE_SIZE];
+   #else
+    int32  fast_huffman[FAST_HUFFMAN_TABLE_SIZE];
+   #endif
+   uint32 *sorted_codewords;
+   int    *sorted_values;
+   int     sorted_entries;
+} Codebook;
+
+typedef struct
+{
+   uint8 order;
+   uint16 rate;
+   uint16 bark_map_size;
+   uint8 amplitude_bits;
+   uint8 amplitude_offset;
+   uint8 number_of_books;
+   uint8 book_list[16]; // varies
+} Floor0;
+
+typedef struct
+{
+   uint8 partitions;
+   uint8 partition_class_list[32]; // varies
+   uint8 class_dimensions[16]; // varies
+   uint8 class_subclasses[16]; // varies
+   uint8 class_masterbooks[16]; // varies
+   int16 subclass_books[16][8]; // varies
+   uint16 Xlist[31*8+2]; // varies
+   uint8 sorted_order[31*8+2];
+   uint8 neighbors[31*8+2][2];
+   uint8 floor1_multiplier;
+   uint8 rangebits;
+   int values;
+} Floor1;
+
+typedef union
+{
+   Floor0 floor0;
+   Floor1 floor1;
+} Floor;
+
+typedef struct
+{
+   uint32 begin, end;
+   uint32 part_size;
+   uint8 classifications;
+   uint8 classbook;
+   uint8 **classdata;
+   int16 (*residue_books)[8];
+} Residue;
+
+typedef struct
+{
+   uint8 magnitude;
+   uint8 angle;
+   uint8 mux;
+} MappingChannel;
+
+typedef struct
+{
+   uint16 coupling_steps;
+   MappingChannel *chan;
+   uint8  submaps;
+   uint8  submap_floor[15]; // varies
+   uint8  submap_residue[15]; // varies
+} Mapping;
+
+typedef struct
+{
+   uint8 blockflag;
+   uint8 mapping;
+   uint16 windowtype;
+   uint16 transformtype;
+} Mode;
+
+typedef struct
+{
+   uint32  goal_crc;    // expected crc if match
+   int     bytes_left;  // bytes left in packet
+   uint32  crc_so_far;  // running crc
+   int     bytes_done;  // bytes processed in _current_ chunk
+   uint32  sample_loc;  // granule pos encoded in page
+} CRCscan;
+
+typedef struct
+{
+   uint32 page_start, page_end;
+   uint32 after_previous_page_start;
+   uint32 first_decoded_sample;
+   uint32 last_decoded_sample;
+} ProbedPage;
+
+struct stb_vorbis
+{
+  // user-accessible info
+   unsigned int sample_rate;
+   int channels;
+
+   unsigned int setup_memory_required;
+   unsigned int temp_memory_required;
+   unsigned int setup_temp_memory_required;
+
+  // input config
+#ifndef STB_VORBIS_NO_STDIO
+   FILE *f;
+   uint32 f_start;
+   int close_on_free;
+#endif
+
+   uint8 *stream;
+   uint8 *stream_start;
+   uint8 *stream_end;
+
+   uint32 stream_len;
+
+   uint8  push_mode;
+
+   uint32 first_audio_page_offset;
+
+   ProbedPage p_first, p_last;
+
+  // memory management
+   stb_vorbis_alloc alloc;
+   int setup_offset;
+   int temp_offset;
+
+  // run-time results
+   int eof;
+   enum STBVorbisError error;
+
+  // user-useful data
+
+  // header info
+   int blocksize[2];
+   int blocksize_0, blocksize_1;
+   int codebook_count;
+   Codebook *codebooks;
+   int floor_count;
+   uint16 floor_types[64]; // varies
+   Floor *floor_config;
+   int residue_count;
+   uint16 residue_types[64]; // varies
+   Residue *residue_config;
+   int mapping_count;
+   Mapping *mapping;
+   int mode_count;
+   Mode mode_config[64];  // varies
+
+   uint32 total_samples;
+
+  // decode buffer
+   float *channel_buffers[STB_VORBIS_MAX_CHANNELS];
+   float *outputs        [STB_VORBIS_MAX_CHANNELS];
+
+   float *previous_window[STB_VORBIS_MAX_CHANNELS];
+   int previous_length;
+
+   #ifndef STB_VORBIS_NO_DEFER_FLOOR
+   int16 *finalY[STB_VORBIS_MAX_CHANNELS];
+   #else
+   float *floor_buffers[STB_VORBIS_MAX_CHANNELS];
+   #endif
+
+   uint32 current_loc; // sample location of next frame to decode
+   int    current_loc_valid;
+
+  // per-blocksize precomputed data
+   
+   // twiddle factors
+   float *A[2],*B[2],*C[2];
+   float *window[2];
+   uint16 *bit_reverse[2];
+
+  // current page/packet/segment streaming info
+   uint32 serial; // stream serial number for verification
+   int last_page;
+   int segment_count;
+   uint8 segments[255];
+   uint8 page_flag;
+   uint8 bytes_in_seg;
+   uint8 first_decode;
+   int next_seg;
+   int last_seg;  // flag that we're on the last segment
+   int last_seg_which; // what was the segment number of the last seg?
+   uint32 acc;
+   int valid_bits;
+   int packet_bytes;
+   int end_seg_with_known_loc;
+   uint32 known_loc_for_packet;
+   int discard_samples_deferred;
+   uint32 samples_output;
+
+  // push mode scanning
+   int page_crc_tests; // only in push_mode: number of tests active; -1 if not searching
+#ifndef STB_VORBIS_NO_PUSHDATA_API
+   CRCscan scan[STB_VORBIS_PUSHDATA_CRC_COUNT];
+#endif
+
+  // sample-access
+   int channel_buffer_start;
+   int channel_buffer_end;
+};
+
+extern int my_prof(int slot);
+//#define stb_prof my_prof
+
+#ifndef stb_prof
+#define stb_prof(x)  0
+#endif
+
+#if defined(STB_VORBIS_NO_PUSHDATA_API)
+   #define IS_PUSH_MODE(f)   FALSE
+#elif defined(STB_VORBIS_NO_PULLDATA_API)
+   #define IS_PUSH_MODE(f)   TRUE
+#else
+   #define IS_PUSH_MODE(f)   ((f)->push_mode)
+#endif
+
+typedef struct stb_vorbis vorb;
+
+static int error(vorb *f, enum STBVorbisError e)
+{
+   f->error = e;
+   if (!f->eof && e != VORBIS_need_more_data) {
+      f->error=e; // breakpoint for debugging
+   }
+   return 0;
+}
+
+
+// these functions are used for allocating temporary memory
+// while decoding. if you can afford the stack space, use
+// alloca(); otherwise, provide a temp buffer and it will
+// allocate out of those.
+
+#define array_size_required(count,size)  (count*(sizeof(void *)+(size)))
+
+#define temp_alloc(f,size)              (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))
+#ifdef dealloca
+#define temp_free(f,p)                  (f->alloc.alloc_buffer ? 0 : dealloca(size))
+#else
+#define temp_free(f,p)                  0
+#endif
+#define temp_alloc_save(f)              ((f)->temp_offset)
+#define temp_alloc_restore(f,p)         ((f)->temp_offset = (p))
+
+#define temp_block_array(f,count,size)  make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)
+
+// given a sufficiently large block of memory, make an array of pointers to subblocks of it
+static void *make_block_array(void *mem, int count, int size)
+{
+   int i;
+   void ** p = (void **) mem;
+   char *q = (char *) (p + count);
+   for (i=0; i < count; ++i) {
+      p[i] = q;
+      q += size;
+   }
+   return p;
+}
+
+static void *setup_malloc(vorb *f, int sz)
+{
+   sz = (sz+3) & ~3;
+   f->setup_memory_required += sz;
+   if (f->alloc.alloc_buffer) {
+      void *p = (char *) f->alloc.alloc_buffer + f->setup_offset;
+      if (f->setup_offset + sz > f->temp_offset) return NULL;
+      f->setup_offset += sz;
+      return p;
+   }
+   return sz ? malloc(sz) : NULL;
+}
+
+static void setup_free(vorb *f, void *p)
+{
+   if (f->alloc.alloc_buffer) return; // do nothing; setup mem is not a stack
+   free(p);
+}
+
+static void *setup_temp_malloc(vorb *f, int sz)
+{
+   sz = (sz+3) & ~3;
+   if (f->alloc.alloc_buffer) {
+      if (f->temp_offset - sz < f->setup_offset) return NULL;
+      f->temp_offset -= sz;
+      return (char *) f->alloc.alloc_buffer + f->temp_offset;
+   }
+   return malloc(sz);
+}
+
+static void setup_temp_free(vorb *f, void *p, size_t sz)
+{
+   if (f->alloc.alloc_buffer) {
+      f->temp_offset += (sz+3)&~3;
+      return;
+   }
+   free(p);
+}
+
+#define CRC32_POLY    0x04c11db7   // from spec
+
+static uint32 crc_table[256];
+static void crc32_init(void)
+{
+   int i,j;
+   uint32 s;
+   for(i=0; i < 256; i++) {
+      for (s=i<<24, j=0; j < 8; ++j)
+         s = (s << 1) ^ (s >= (1<<31) ? CRC32_POLY : 0);
+      crc_table[i] = s;
+   }
+}
+
+static __forceinline uint32 crc32_update(uint32 crc, uint8 byte)
+{
+   return (crc << 8) ^ crc_table[byte ^ (crc >> 24)];
+}
+
+
+// used in setup, and for huffman that doesn't go fast path
+static unsigned int bit_reverse(unsigned int n)
+{
+  n = ((n & 0xAAAAAAAA) >>  1) | ((n & 0x55555555) << 1);
+  n = ((n & 0xCCCCCCCC) >>  2) | ((n & 0x33333333) << 2);
+  n = ((n & 0xF0F0F0F0) >>  4) | ((n & 0x0F0F0F0F) << 4);
+  n = ((n & 0xFF00FF00) >>  8) | ((n & 0x00FF00FF) << 8);
+  return (n >> 16) | (n << 16);
+}
+
+static float square(float x)
+{
+   return x*x;
+}
+
+// this is a weird definition of log2() for which log2(1) = 1, log2(2) = 2, log2(4) = 3
+// as required by the specification. fast(?) implementation from stb.h
+// @OPTIMIZE: called multiple times per-packet with "constants"; move to setup
+static int ilog(int32 n)
+{
+   static signed char log2_4[16] = { 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4 };
+
+   // 2 compares if n < 16, 3 compares otherwise (4 if signed or n > 1<<29)
+   if (n < (1U << 14))
+        if (n < (1U <<  4))        return     0 + log2_4[n      ];
+        else if (n < (1U <<  9))      return  5 + log2_4[n >>  5];
+             else                     return 10 + log2_4[n >> 10];
+   else if (n < (1U << 24))
+             if (n < (1U << 19))      return 15 + log2_4[n >> 15];
+             else                     return 20 + log2_4[n >> 20];
+        else if (n < (1U << 29))      return 25 + log2_4[n >> 25];
+             else if (n < (1U << 31)) return 30 + log2_4[n >> 30];
+                  else                return 0; // signed n returns 0
+}
+
+#ifndef M_PI
+  #define M_PI  3.14159265358979323846264f  // from CRC
+#endif
+
+// code length assigned to a value with no huffman encoding
+#define NO_CODE   255
+
+/////////////////////// LEAF SETUP FUNCTIONS //////////////////////////
+//
+// these functions are only called at setup, and only a few times
+// per file
+
+static float float32_unpack(uint32 x)
+{
+   // from the specification
+   uint32 mantissa = x & 0x1fffff;
+   uint32 sign = x & 0x80000000;
+   uint32 exp = (x & 0x7fe00000) >> 21;
+   double res = sign ? -(double)mantissa : (double)mantissa;
+   return (float) ldexp((float)res, exp-788);
+}
+
+
+// zlib & jpeg huffman tables assume that the output symbols
+// can either be arbitrarily arranged, or have monotonically
+// increasing frequencies--they rely on the lengths being sorted;
+// this makes for a very simple generation algorithm.
+// vorbis allows a huffman table with non-sorted lengths. This
+// requires a more sophisticated construction, since symbols in
+// order do not map to huffman codes "in order".
+static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values)
+{
+   if (!c->sparse) {
+      c->codewords      [symbol] = huff_code;
+   } else {
+      c->codewords       [count] = huff_code;
+      c->codeword_lengths[count] = len;
+      values             [count] = symbol;
+   }
+}
+
+static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)
+{
+   int i,k,m=0;
+   uint32 available[32];
+
+   memset(available, 0, sizeof(available));
+   // find the first entry
+   for (k=0; k < n; ++k) if (len[k] < NO_CODE) break;
+   if (k == n) { assert(c->sorted_entries == 0); return TRUE; }
+   // add to the list
+   add_entry(c, 0, k, m++, len[k], values);
+   // add all available leaves
+   for (i=1; i <= len[k]; ++i)
+      available[i] = 1 << (32-i);
+   // note that the above code treats the first case specially,
+   // but it's really the same as the following code, so they
+   // could probably be combined (except the initial code is 0,
+   // and I use 0 in available[] to mean 'empty')
+   for (i=k+1; i < n; ++i) {
+      uint32 res;
+      int z = len[i], y;
+      if (z == NO_CODE) continue;
+      // find lowest available leaf (should always be earliest,
+      // which is what the specification calls for)
+      // note that this property, and the fact we can never have
+      // more than one free leaf at a given level, isn't totally
+      // trivial to prove, but it seems true and the assert never
+      // fires, so!
+      while (z > 0 && !available[z]) --z;
+      if (z == 0) { assert(0); return FALSE; }
+      res = available[z];
+      available[z] = 0;
+      add_entry(c, bit_reverse(res), i, m++, len[i], values);
+      // propogate availability up the tree
+      if (z != len[i]) {
+         for (y=len[i]; y > z; --y) {
+            assert(available[y] == 0);
+            available[y] = res + (1 << (32-y));
+         }
+      }
+   }
+   return TRUE;
+}
+
+// accelerated huffman table allows fast O(1) match of all symbols
+// of length <= STB_VORBIS_FAST_HUFFMAN_LENGTH
+static void compute_accelerated_huffman(Codebook *c)
+{
+   int i, len;
+   for (i=0; i < FAST_HUFFMAN_TABLE_SIZE; ++i)
+      c->fast_huffman[i] = -1;
+
+   len = c->sparse ? c->sorted_entries : c->entries;
+   #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT
+   if (len > 32767) len = 32767; // largest possible value we can encode!
+   #endif
+   for (i=0; i < len; ++i) {
+      if (c->codeword_lengths[i] <= STB_VORBIS_FAST_HUFFMAN_LENGTH) {
+         uint32 z = c->sparse ? bit_reverse(c->sorted_codewords[i]) : c->codewords[i];
+         // set table entries for all bit combinations in the higher bits
+         while (z < FAST_HUFFMAN_TABLE_SIZE) {
+             c->fast_huffman[z] = i;
+             z += 1 << c->codeword_lengths[i];
+         }
+      }
+   }
+}
+
+static int uint32_compare(const void *p, const void *q)
+{
+   uint32 x = * (uint32 *) p;
+   uint32 y = * (uint32 *) q;
+   return x < y ? -1 : x > y;
+}
+
+static int include_in_sort(Codebook *c, uint8 len)
+{
+   if (c->sparse) { assert(len != NO_CODE); return TRUE; }
+   if (len == NO_CODE) return FALSE;
+   if (len > STB_VORBIS_FAST_HUFFMAN_LENGTH) return TRUE;
+   return FALSE;
+}
+
+// if the fast table above doesn't work, we want to binary
+// search them... need to reverse the bits
+static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values)
+{
+   int i, len;
+   // build a list of all the entries
+   // OPTIMIZATION: don't include the short ones, since they'll be caught by FAST_HUFFMAN.
+   // this is kind of a frivolous optimization--I don't see any performance improvement,
+   // but it's like 4 extra lines of code, so.
+   if (!c->sparse) {
+      int k = 0;
+      for (i=0; i < c->entries; ++i)
+         if (include_in_sort(c, lengths[i])) 
+            c->sorted_codewords[k++] = bit_reverse(c->codewords[i]);
+      assert(k == c->sorted_entries);
+   } else {
+      for (i=0; i < c->sorted_entries; ++i)
+         c->sorted_codewords[i] = bit_reverse(c->codewords[i]);
+   }
+
+   qsort(c->sorted_codewords, c->sorted_entries, sizeof(c->sorted_codewords[0]), uint32_compare);
+   c->sorted_codewords[c->sorted_entries] = 0xffffffff;
+
+   len = c->sparse ? c->sorted_entries : c->entries;
+   // now we need to indicate how they correspond; we could either
+   //   #1: sort a different data structure that says who they correspond to
+   //   #2: for each sorted entry, search the original list to find who corresponds
+   //   #3: for each original entry, find the sorted entry
+   // #1 requires extra storage, #2 is slow, #3 can use binary search!
+   for (i=0; i < len; ++i) {
+      int huff_len = c->sparse ? lengths[values[i]] : lengths[i];
+      if (include_in_sort(c,huff_len)) {
+         uint32 code = bit_reverse(c->codewords[i]);
+         int x=0, n=c->sorted_entries;
+         while (n > 1) {
+            // invariant: sc[x] <= code < sc[x+n]
+            int m = x + (n >> 1);
+            if (c->sorted_codewords[m] <= code) {
+               x = m;
+               n -= (n>>1);
+            } else {
+               n >>= 1;
+            }
+         }
+         assert(c->sorted_codewords[x] == code);
+         if (c->sparse) {
+            c->sorted_values[x] = values[i];
+            c->codeword_lengths[x] = huff_len;
+         } else {
+            c->sorted_values[x] = i;
+         }
+      }
+   }
+}
+
+// only run while parsing the header (3 times)
+static int vorbis_validate(uint8 *data)
+{
+   static uint8 vorbis[6] = { 'v', 'o', 'r', 'b', 'i', 's' };
+   return memcmp(data, vorbis, 6) == 0;
+}
+
+// called from setup only, once per code book
+// (formula implied by specification)
+static int lookup1_values(int entries, int dim)
+{
+   int r = (int) floor(exp((float) log((float) entries) / dim));
+   if ((int) floor(pow((float) r+1, dim)) <= entries)   // (int) cast for MinGW warning;
+      ++r;                                              // floor() to avoid _ftol() when non-CRT
+   assert(pow((float) r+1, dim) > entries);
+   assert((int) floor(pow((float) r, dim)) <= entries); // (int),floor() as above
+   return r;
+}
+
+// called twice per file
+static void compute_twiddle_factors(int n, float *A, float *B, float *C)
+{
+   int n4 = n >> 2, n8 = n >> 3;
+   int k,k2;
+
+   for (k=k2=0; k < n4; ++k,k2+=2) {
+      A[k2  ] = (float)  cos(4*k*M_PI/n);
+      A[k2+1] = (float) -sin(4*k*M_PI/n);
+      B[k2  ] = (float)  cos((k2+1)*M_PI/n/2) * 0.5f;
+      B[k2+1] = (float)  sin((k2+1)*M_PI/n/2) * 0.5f;
+   }
+   for (k=k2=0; k < n8; ++k,k2+=2) {
+      C[k2  ] = (float)  cos(2*(k2+1)*M_PI/n);
+      C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n);
+   }
+}
+
+static void compute_window(int n, float *window)
+{
+   int n2 = n >> 1, i;
+   for (i=0; i < n2; ++i)
+      window[i] = (float) sin(0.5 * M_PI * square((float) sin((i - 0 + 0.5) / n2 * 0.5 * M_PI)));
+}
+
+static void compute_bitreverse(int n, uint16 *rev)
+{
+   int ld = ilog(n) - 1; // ilog is off-by-one from normal definitions
+   int i, n8 = n >> 3;
+   for (i=0; i < n8; ++i)
+      rev[i] = (bit_reverse(i) >> (32-ld+3)) << 2;
+}
+
+static int init_blocksize(vorb *f, int b, int n)
+{
+   int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3;
+   f->A[b] = (float *) setup_malloc(f, sizeof(float) * n2);
+   f->B[b] = (float *) setup_malloc(f, sizeof(float) * n2);
+   f->C[b] = (float *) setup_malloc(f, sizeof(float) * n4);
+   if (!f->A[b] || !f->B[b] || !f->C[b]) return error(f, VORBIS_outofmem);
+   compute_twiddle_factors(n, f->A[b], f->B[b], f->C[b]);
+   f->window[b] = (float *) setup_malloc(f, sizeof(float) * n2);
+   if (!f->window[b]) return error(f, VORBIS_outofmem);
+   compute_window(n, f->window[b]);
+   f->bit_reverse[b] = (uint16 *) setup_malloc(f, sizeof(uint16) * n8);
+   if (!f->bit_reverse[b]) return error(f, VORBIS_outofmem);
+   compute_bitreverse(n, f->bit_reverse[b]);
+   return TRUE;
+}
+
+static void neighbors(uint16 *x, int n, int *plow, int *phigh)
+{
+   int low = -1;
+   int high = 65536;
+   int i;
+   for (i=0; i < n; ++i) {
+      if (x[i] > low  && x[i] < x[n]) { *plow  = i; low = x[i]; }
+      if (x[i] < high && x[i] > x[n]) { *phigh = i; high = x[i]; }
+   }
+}
+
+// this has been repurposed so y is now the original index instead of y
+typedef struct
+{
+   uint16 x,y;
+} Point;
+
+int point_compare(const void *p, const void *q)
+{
+   Point *a = (Point *) p;
+   Point *b = (Point *) q;
+   return a->x < b->x ? -1 : a->x > b->x;
+}
+
+//
+/////////////////////// END LEAF SETUP FUNCTIONS //////////////////////////
+
+
+#if defined(STB_VORBIS_NO_STDIO)
+   #define USE_MEMORY(z)    TRUE
+#else
+   #define USE_MEMORY(z)    ((z)->stream)
+#endif
+
+static uint8 get8(vorb *z)
+{
+   if (USE_MEMORY(z)) {
+      if (z->stream >= z->stream_end) { z->eof = TRUE; return 0; }
+      return *z->stream++;
+   }
+
+   #ifndef STB_VORBIS_NO_STDIO
+   {
+   int c = fgetc(z->f);
+   if (c == EOF) { z->eof = TRUE; return 0; }
+   return c;
+   }
+   #endif
+}
+
+static uint32 get32(vorb *f)
+{
+   uint32 x;
+   x = get8(f);
+   x += get8(f) << 8;
+   x += get8(f) << 16;
+   x += get8(f) << 24;
+   return x;
+}
+
+static int getn(vorb *z, uint8 *data, int n)
+{
+   if (USE_MEMORY(z)) {
+      if (z->stream+n > z->stream_end) { z->eof = 1; return 0; }
+      memcpy(data, z->stream, n);
+      z->stream += n;
+      return 1;
+   }
+
+   #ifndef STB_VORBIS_NO_STDIO   
+   if (fread(data, n, 1, z->f) == 1)
+      return 1;
+   else {
+      z->eof = 1;
+      return 0;
+   }
+   #endif
+}
+
+static void skip(vorb *z, int n)
+{
+   if (USE_MEMORY(z)) {
+      z->stream += n;
+      if (z->stream >= z->stream_end) z->eof = 1;
+      return;
+   }
+   #ifndef STB_VORBIS_NO_STDIO
+   {
+      long x = ftell(z->f);
+      fseek(z->f, x+n, SEEK_SET);
+   }
+   #endif
+}
+
+static int set_file_offset(stb_vorbis *f, unsigned int loc)
+{
+   #ifndef STB_VORBIS_NO_PUSHDATA_API
+   if (f->push_mode) return 0;
+   #endif
+   f->eof = 0;
+   if (USE_MEMORY(f)) {
+      if (f->stream_start + loc >= f->stream_end || f->stream_start + loc < f->stream_start) {
+         f->stream = f->stream_end;
+         f->eof = 1;
+         return 0;
+      } else {
+         f->stream = f->stream_start + loc;
+         return 1;
+      }
+   }
+   #ifndef STB_VORBIS_NO_STDIO
+   if (loc + f->f_start < loc || loc >= 0x80000000) {
+      loc = 0x7fffffff;
+      f->eof = 1;
+   } else {
+      loc += f->f_start;
+   }
+   if (!fseek(f->f, loc, SEEK_SET))
+      return 1;
+   f->eof = 1;
+   fseek(f->f, f->f_start, SEEK_END);
+   return 0;
+   #endif
+}
+
+
+static uint8 ogg_page_header[4] = { 0x4f, 0x67, 0x67, 0x53 };
+
+static int capture_pattern(vorb *f)
+{
+   if (0x4f != get8(f)) return FALSE;
+   if (0x67 != get8(f)) return FALSE;
+   if (0x67 != get8(f)) return FALSE;
+   if (0x53 != get8(f)) return FALSE;
+   return TRUE;
+}
+
+#define PAGEFLAG_continued_packet   1
+#define PAGEFLAG_first_page         2
+#define PAGEFLAG_last_page          4
+
+static int start_page_no_capturepattern(vorb *f)
+{
+   uint32 loc0,loc1,n,i;
+   // stream structure version
+   if (0 != get8(f)) return error(f, VORBIS_invalid_stream_structure_version);
+   // header flag
+   f->page_flag = get8(f);
+   // absolute granule position
+   loc0 = get32(f); 
+   loc1 = get32(f);
+   // @TODO: validate loc0,loc1 as valid positions?
+   // stream serial number -- vorbis doesn't interleave, so discard
+   get32(f);
+   //if (f->serial != get32(f)) return error(f, VORBIS_incorrect_stream_serial_number);
+   // page sequence number
+   n = get32(f);
+   f->last_page = n;
+   // CRC32
+   get32(f);
+   // page_segments
+   f->segment_count = get8(f);
+   if (!getn(f, f->segments, f->segment_count))
+      return error(f, VORBIS_unexpected_eof);
+   // assume we _don't_ know any the sample position of any segments
+   f->end_seg_with_known_loc = -2;
+   if (loc0 != ~0 || loc1 != ~0) {
+      // determine which packet is the last one that will complete
+      for (i=f->segment_count-1; i >= 0; --i)
+         if (f->segments[i] < 255)
+            break;
+      // 'i' is now the index of the _last_ segment of a packet that ends
+      if (i >= 0) {
+         f->end_seg_with_known_loc = i;
+         f->known_loc_for_packet   = loc0;
+      }
+   }
+   if (f->first_decode) {
+      int i,len;
+      ProbedPage p;
+      len = 0;
+      for (i=0; i < f->segment_count; ++i)
+         len += f->segments[i];
+      len += 27 + f->segment_count;
+      p.page_start = f->first_audio_page_offset;
+      p.page_end = p.page_start + len;
+      p.after_previous_page_start = p.page_start;
+      p.first_decoded_sample = 0;
+      p.last_decoded_sample = loc0;
+      f->p_first = p;
+   }
+   f->next_seg = 0;
+   return TRUE;
+}
+
+static int start_page(vorb *f)
+{
+   if (!capture_pattern(f)) return error(f, VORBIS_missing_capture_pattern);
+   return start_page_no_capturepattern(f);
+}
+
+static int start_packet(vorb *f)
+{
+   while (f->next_seg == -1) {
+      if (!start_page(f)) return FALSE;
+      if (f->page_flag & PAGEFLAG_continued_packet)
+         return error(f, VORBIS_continued_packet_flag_invalid);
+   }
+   f->last_seg = FALSE;
+   f->valid_bits = 0;
+   f->packet_bytes = 0;
+   f->bytes_in_seg = 0;
+   // f->next_seg is now valid
+   return TRUE;
+}
+
+static int maybe_start_packet(vorb *f)
+{
+   if (f->next_seg == -1) {
+      int x = get8(f);
+      if (f->eof) return FALSE; // EOF at page boundary is not an error!
+      if (0x4f != x      ) return error(f, VORBIS_missing_capture_pattern);
+      if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern);
+      if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern);
+      if (0x53 != get8(f)) return error(f, VORBIS_missing_capture_pattern);
+      if (!start_page_no_capturepattern(f)) return FALSE;
+      if (f->page_flag & PAGEFLAG_continued_packet) {
+         // set up enough state that we can read this packet if we want,
+         // e.g. during recovery
+         f->last_seg = FALSE;
+         f->bytes_in_seg = 0;
+         return error(f, VORBIS_continued_packet_flag_invalid);
+      }
+   }
+   return start_packet(f);
+}
+
+static int next_segment(vorb *f)
+{
+   int len;
+   if (f->last_seg) return 0;
+   if (f->next_seg == -1) {
+      f->last_seg_which = f->segment_count-1; // in case start_page fails
+      if (!start_page(f)) { f->last_seg = 1; return 0; }
+      if (!(f->page_flag & PAGEFLAG_continued_packet)) return error(f, VORBIS_continued_packet_flag_invalid);
+   }
+   len = f->segments[f->next_seg++];
+   if (len < 255) {
+      f->last_seg = TRUE;
+      f->last_seg_which = f->next_seg-1;
+   }
+   if (f->next_seg >= f->segment_count)
+      f->next_seg = -1;
+   assert(f->bytes_in_seg == 0);
+   f->bytes_in_seg = len;
+   return len;
+}
+
+#define EOP    (-1)
+#define INVALID_BITS  (-1)
+
+static int get8_packet_raw(vorb *f)
+{
+   if (!f->bytes_in_seg)
+      if (f->last_seg) return EOP;
+      else if (!next_segment(f)) return EOP;
+   assert(f->bytes_in_seg > 0);
+   --f->bytes_in_seg;
+   ++f->packet_bytes;
+   return get8(f);
+}
+
+static int get8_packet(vorb *f)
+{
+   int x = get8_packet_raw(f);
+   f->valid_bits = 0;
+   return x;
+}
+
+static void flush_packet(vorb *f)
+{
+   while (get8_packet_raw(f) != EOP);
+}
+
+// @OPTIMIZE: this is the secondary bit decoder, so it's probably not as important
+// as the huffman decoder?
+static uint32 get_bits(vorb *f, int n)
+{
+   uint32 z;
+
+   if (f->valid_bits < 0) return 0;
+   if (f->valid_bits < n) {
+      if (n > 24) {
+         // the accumulator technique below would not work correctly in this case
+         z = get_bits(f, 24);
+         z += get_bits(f, n-24) << 24;
+         return z;
+      }
+      if (f->valid_bits == 0) f->acc = 0;
+      while (f->valid_bits < n) {
+         int z = get8_packet_raw(f);
+         if (z == EOP) {
+            f->valid_bits = INVALID_BITS;
+            return 0;
+         }
+         f->acc += z << f->valid_bits;
+         f->valid_bits += 8;
+      }
+   }
+   if (f->valid_bits < 0) return 0;
+   z = f->acc & ((1 << n)-1);
+   f->acc >>= n;
+   f->valid_bits -= n;
+   return z;
+}
+
+static int32 get_bits_signed(vorb *f, int n)
+{
+   uint32 z = get_bits(f, n);
+   if (z & (1 << (n-1)))
+      z += ~((1 << n) - 1);
+   return (int32) z;
+}
+
+// @OPTIMIZE: primary accumulator for huffman
+// expand the buffer to as many bits as possible without reading off end of packet
+// it might be nice to allow f->valid_bits and f->acc to be stored in registers,
+// e.g. cache them locally and decode locally
+static __forceinline void prep_huffman(vorb *f)
+{
+   if (f->valid_bits <= 24) {
+      if (f->valid_bits == 0) f->acc = 0;
+      do {
+         int z;
+         if (f->last_seg && !f->bytes_in_seg) return;
+         z = get8_packet_raw(f);
+         if (z == EOP) return;
+         f->acc += z << f->valid_bits;
+         f->valid_bits += 8;
+      } while (f->valid_bits <= 24);
+   }
+}
+
+enum
+{
+   VORBIS_packet_id = 1,
+   VORBIS_packet_comment = 3,
+   VORBIS_packet_setup = 5,
+};
+
+static int codebook_decode_scalar_raw(vorb *f, Codebook *c)
+{
+   int i;
+   prep_huffman(f);
+
+   assert(c->sorted_codewords || c->codewords);
+   // cases to use binary search: sorted_codewords && !c->codewords
+   //                             sorted_codewords && c->entries > 8
+   if (c->entries > 8 ? c->sorted_codewords!=NULL : !c->codewords) {
+      // binary search
+      uint32 code = bit_reverse(f->acc);
+      int x=0, n=c->sorted_entries, len;
+
+      while (n > 1) {
+         // invariant: sc[x] <= code < sc[x+n]
+         int m = x + (n >> 1);
+         if (c->sorted_codewords[m] <= code) {
+            x = m;
+            n -= (n>>1);
+         } else {
+            n >>= 1;
+         }
+      }
+      // x is now the sorted index
+      if (!c->sparse) x = c->sorted_values[x];
+      // x is now sorted index if sparse, or symbol otherwise
+      len = c->codeword_lengths[x];
+      if (f->valid_bits >= len) {
+         f->acc >>= len;
+         f->valid_bits -= len;
+         return x;
+      }
+
+      f->valid_bits = 0;
+      return -1;
+   }
+
+   // if small, linear search
+   assert(!c->sparse);
+   for (i=0; i < c->entries; ++i) {
+      if (c->codeword_lengths[i] == NO_CODE) continue;
+      if (c->codewords[i] == (f->acc & ((1 << c->codeword_lengths[i])-1))) {
+         if (f->valid_bits >= c->codeword_lengths[i]) {
+            f->acc >>= c->codeword_lengths[i];
+            f->valid_bits -= c->codeword_lengths[i];
+            return i;
+         }
+         f->valid_bits = 0;
+         return -1;
+      }
+   }
+
+   error(f, VORBIS_invalid_stream);
+   f->valid_bits = 0;
+   return -1;
+}
+
+static int codebook_decode_scalar(vorb *f, Codebook *c)
+{
+   int i;
+   if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH)
+      prep_huffman(f);
+   // fast huffman table lookup
+   i = f->acc & FAST_HUFFMAN_TABLE_MASK;
+   i = c->fast_huffman[i];
+   if (i >= 0) {
+      f->acc >>= c->codeword_lengths[i];
+      f->valid_bits -= c->codeword_lengths[i];
+      if (f->valid_bits < 0) { f->valid_bits = 0; return -1; }
+      return i;
+   }
+   return codebook_decode_scalar_raw(f,c);
+}
+
+#ifndef STB_VORBIS_NO_INLINE_DECODE
+
+#define DECODE_RAW(var, f,c)                                  \
+   if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH)        \
+      prep_huffman(f);                                        \
+   var = f->acc & FAST_HUFFMAN_TABLE_MASK;                    \
+   var = c->fast_huffman[var];                                \
+   if (var >= 0) {                                            \
+      int n = c->codeword_lengths[var];                       \
+      f->acc >>= n;                                           \
+      f->valid_bits -= n;                                     \
+      if (f->valid_bits < 0) { f->valid_bits = 0; var = -1; } \
+   } else {                                                   \
+      var = codebook_decode_scalar_raw(f,c);                  \
+   }
+
+#else
+
+#define DECODE_RAW(var,f,c)    var = codebook_decode_scalar(f,c);
+
+#endif
+
+#define DECODE(var,f,c)                                       \
+   DECODE_RAW(var,f,c)                                        \
+   if (c->sparse) var = c->sorted_values[var];
+
+#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
+  #define DECODE_VQ(var,f,c)   DECODE_RAW(var,f,c)
+#else
+  #define DECODE_VQ(var,f,c)   DECODE(var,f,c)
+#endif
+
+
+
+
+
+
+// CODEBOOK_ELEMENT_FAST is an optimization for the CODEBOOK_FLOATS case
+// where we avoid one addition
+#ifndef STB_VORBIS_CODEBOOK_FLOATS
+   #define CODEBOOK_ELEMENT(c,off)          (c->multiplicands[off] * c->delta_value + c->minimum_value)
+   #define CODEBOOK_ELEMENT_FAST(c,off)     (c->multiplicands[off] * c->delta_value)
+   #define CODEBOOK_ELEMENT_BASE(c)         (c->minimum_value)
+#else
+   #define CODEBOOK_ELEMENT(c,off)          (c->multiplicands[off])
+   #define CODEBOOK_ELEMENT_FAST(c,off)     (c->multiplicands[off])
+   #define CODEBOOK_ELEMENT_BASE(c)         (0)
+#endif
+
+static int codebook_decode_start(vorb *f, Codebook *c, int len)
+{
+   int z = -1;
+
+   // type 0 is only legal in a scalar context
+   if (c->lookup_type == 0)
+      error(f, VORBIS_invalid_stream);
+   else {
+      DECODE_VQ(z,f,c);
+      if (c->sparse) assert(z < c->sorted_entries);
+      if (z < 0) {  // check for EOP
+         if (!f->bytes_in_seg)
+            if (f->last_seg)
+               return z;
+         error(f, VORBIS_invalid_stream);
+      }
+   }
+   return z;
+}
+
+static int codebook_decode(vorb *f, Codebook *c, float *output, int len)
+{
+   int i,z = codebook_decode_start(f,c,len);
+   if (z < 0) return FALSE;
+   if (len > c->dimensions) len = c->dimensions;
+
+#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
+   if (c->lookup_type == 1) {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      int div = 1;
+      for (i=0; i < len; ++i) {
+         int off = (z / div) % c->lookup_values;
+         float val = CODEBOOK_ELEMENT_FAST(c,off) + last;
+         output[i] += val;
+         if (c->sequence_p) last = val + c->minimum_value;
+         div *= c->lookup_values;
+      }
+      return TRUE;
+   }
+#endif
+
+   z *= c->dimensions;
+   if (c->sequence_p) {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      for (i=0; i < len; ++i) {
+         float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+         output[i] += val;
+         last = val + c->minimum_value;
+      }
+   } else {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      for (i=0; i < len; ++i) {
+         output[i] += CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+      }
+   }
+
+   return TRUE;
+}
+
+static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step)
+{
+   int i,z = codebook_decode_start(f,c,len);
+   float last = CODEBOOK_ELEMENT_BASE(c);
+   if (z < 0) return FALSE;
+   if (len > c->dimensions) len = c->dimensions;
+
+#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
+   if (c->lookup_type == 1) {
+      int div = 1;
+      for (i=0; i < len; ++i) {
+         int off = (z / div) % c->lookup_values;
+         float val = CODEBOOK_ELEMENT_FAST(c,off) + last;
+         output[i*step] += val;
+         if (c->sequence_p) last = val;
+         div *= c->lookup_values;
+      }
+      return TRUE;
+   }
+#endif
+
+   z *= c->dimensions;
+   for (i=0; i < len; ++i) {
+      float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+      output[i*step] += val;
+      if (c->sequence_p) last = val;
+   }
+
+   return TRUE;
+}
+
+static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode)
+{
+   int c_inter = *c_inter_p;
+   int p_inter = *p_inter_p;
+   int i,z, effective = c->dimensions;
+
+   // type 0 is only legal in a scalar context
+   if (c->lookup_type == 0)   return error(f, VORBIS_invalid_stream);
+
+   while (total_decode > 0) {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      DECODE_VQ(z,f,c);
+      #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
+      assert(!c->sparse || z < c->sorted_entries);
+      #endif
+      if (z < 0) {
+         if (!f->bytes_in_seg)
+            if (f->last_seg) return FALSE;
+         return error(f, VORBIS_invalid_stream);
+      }
+
+      // if this will take us off the end of the buffers, stop short!
+      // we check by computing the length of the virtual interleaved
+      // buffer (len*ch), our current offset within it (p_inter*ch)+(c_inter),
+      // and the length we'll be using (effective)
+      if (c_inter + p_inter*ch + effective > len * ch) {
+         effective = len*ch - (p_inter*ch - c_inter);
+      }
+
+   #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
+      if (c->lookup_type == 1) {
+         int div = 1;
+         for (i=0; i < effective; ++i) {
+            int off = (z / div) % c->lookup_values;
+            float val = CODEBOOK_ELEMENT_FAST(c,off) + last;
+            outputs[c_inter][p_inter] += val;
+            if (++c_inter == ch) { c_inter = 0; ++p_inter; }
+            if (c->sequence_p) last = val;
+            div *= c->lookup_values;
+         }
+      } else
+   #endif
+      {
+         z *= c->dimensions;
+         if (c->sequence_p) {
+            for (i=0; i < effective; ++i) {
+               float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+               outputs[c_inter][p_inter] += val;
+               if (++c_inter == ch) { c_inter = 0; ++p_inter; }
+               last = val;
+            }
+         } else {
+            for (i=0; i < effective; ++i) {
+               float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+               outputs[c_inter][p_inter] += val;
+               if (++c_inter == ch) { c_inter = 0; ++p_inter; }
+            }
+         }
+      }
+
+      total_decode -= effective;
+   }
+   *c_inter_p = c_inter;
+   *p_inter_p = p_inter;
+   return TRUE;
+}
+
+#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
+static int codebook_decode_deinterleave_repeat_2(vorb *f, Codebook *c, float **outputs, int *c_inter_p, int *p_inter_p, int len, int total_decode)
+{
+   int c_inter = *c_inter_p;
+   int p_inter = *p_inter_p;
+   int i,z, effective = c->dimensions;
+
+   // type 0 is only legal in a scalar context
+   if (c->lookup_type == 0)   return error(f, VORBIS_invalid_stream);
+
+   while (total_decode > 0) {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      DECODE_VQ(z,f,c);
+
+      if (z < 0) {
+         if (!f->bytes_in_seg)
+            if (f->last_seg) return FALSE;
+         return error(f, VORBIS_invalid_stream);
+      }
+
+      // if this will take us off the end of the buffers, stop short!
+      // we check by computing the length of the virtual interleaved
+      // buffer (len*ch), our current offset within it (p_inter*ch)+(c_inter),
+      // and the length we'll be using (effective)
+      if (c_inter + p_inter*2 + effective > len * 2) {
+         effective = len*2 - (p_inter*2 - c_inter);
+      }
+
+      {
+         z *= c->dimensions;
+         stb_prof(11);
+         if (c->sequence_p) {
+            // haven't optimized this case because I don't have any examples
+            for (i=0; i < effective; ++i) {
+               float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+               outputs[c_inter][p_inter] += val;
+               if (++c_inter == 2) { c_inter = 0; ++p_inter; }
+               last = val;
+            }
+         } else {
+            i=0;
+            if (c_inter == 1) {
+               float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+               outputs[c_inter][p_inter] += val;
+               c_inter = 0; ++p_inter;
+               ++i;
+            }
+            {
+               float *z0 = outputs[0];
+               float *z1 = outputs[1];
+               for (; i+1 < effective;) {
+                  z0[p_inter] += CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+                  z1[p_inter] += CODEBOOK_ELEMENT_FAST(c,z+i+1) + last;
+                  ++p_inter;
+                  i += 2;
+               }
+            }
+            if (i < effective) {
+               float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+               outputs[c_inter][p_inter] += val;
+               if (++c_inter == 2) { c_inter = 0; ++p_inter; }
+            }
+         }
+      }
+
+      total_decode -= effective;
+   }
+   *c_inter_p = c_inter;
+   *p_inter_p = p_inter;
+   return TRUE;
+}
+#endif
+
+static int predict_point(int x, int x0, int x1, int y0, int y1)
+{
+   int dy = y1 - y0;
+   int adx = x1 - x0;
+   // @OPTIMIZE: force int division to round in the right direction... is this necessary on x86?
+   int err = abs(dy) * (x - x0);
+   int off = err / adx;
+   return dy < 0 ? y0 - off : y0 + off;
+}
+
+// the following table is block-copied from the specification
+static float inverse_db_table[256] =
+{
+  1.0649863e-07f, 1.1341951e-07f, 1.2079015e-07f, 1.2863978e-07f, 
+  1.3699951e-07f, 1.4590251e-07f, 1.5538408e-07f, 1.6548181e-07f, 
+  1.7623575e-07f, 1.8768855e-07f, 1.9988561e-07f, 2.1287530e-07f, 
+  2.2670913e-07f, 2.4144197e-07f, 2.5713223e-07f, 2.7384213e-07f, 
+  2.9163793e-07f, 3.1059021e-07f, 3.3077411e-07f, 3.5226968e-07f, 
+  3.7516214e-07f, 3.9954229e-07f, 4.2550680e-07f, 4.5315863e-07f, 
+  4.8260743e-07f, 5.1396998e-07f, 5.4737065e-07f, 5.8294187e-07f, 
+  6.2082472e-07f, 6.6116941e-07f, 7.0413592e-07f, 7.4989464e-07f, 
+  7.9862701e-07f, 8.5052630e-07f, 9.0579828e-07f, 9.6466216e-07f, 
+  1.0273513e-06f, 1.0941144e-06f, 1.1652161e-06f, 1.2409384e-06f, 
+  1.3215816e-06f, 1.4074654e-06f, 1.4989305e-06f, 1.5963394e-06f, 
+  1.7000785e-06f, 1.8105592e-06f, 1.9282195e-06f, 2.0535261e-06f, 
+  2.1869758e-06f, 2.3290978e-06f, 2.4804557e-06f, 2.6416497e-06f, 
+  2.8133190e-06f, 2.9961443e-06f, 3.1908506e-06f, 3.3982101e-06f, 
+  3.6190449e-06f, 3.8542308e-06f, 4.1047004e-06f, 4.3714470e-06f, 
+  4.6555282e-06f, 4.9580707e-06f, 5.2802740e-06f, 5.6234160e-06f, 
+  5.9888572e-06f, 6.3780469e-06f, 6.7925283e-06f, 7.2339451e-06f, 
+  7.7040476e-06f, 8.2047000e-06f, 8.7378876e-06f, 9.3057248e-06f, 
+  9.9104632e-06f, 1.0554501e-05f, 1.1240392e-05f, 1.1970856e-05f, 
+  1.2748789e-05f, 1.3577278e-05f, 1.4459606e-05f, 1.5399272e-05f, 
+  1.6400004e-05f, 1.7465768e-05f, 1.8600792e-05f, 1.9809576e-05f, 
+  2.1096914e-05f, 2.2467911e-05f, 2.3928002e-05f, 2.5482978e-05f, 
+  2.7139006e-05f, 2.8902651e-05f, 3.0780908e-05f, 3.2781225e-05f, 
+  3.4911534e-05f, 3.7180282e-05f, 3.9596466e-05f, 4.2169667e-05f, 
+  4.4910090e-05f, 4.7828601e-05f, 5.0936773e-05f, 5.4246931e-05f, 
+  5.7772202e-05f, 6.1526565e-05f, 6.5524908e-05f, 6.9783085e-05f, 
+  7.4317983e-05f, 7.9147585e-05f, 8.4291040e-05f, 8.9768747e-05f, 
+  9.5602426e-05f, 0.00010181521f, 0.00010843174f, 0.00011547824f, 
+  0.00012298267f, 0.00013097477f, 0.00013948625f, 0.00014855085f, 
+  0.00015820453f, 0.00016848555f, 0.00017943469f, 0.00019109536f, 
+  0.00020351382f, 0.00021673929f, 0.00023082423f, 0.00024582449f, 
+  0.00026179955f, 0.00027881276f, 0.00029693158f, 0.00031622787f, 
+  0.00033677814f, 0.00035866388f, 0.00038197188f, 0.00040679456f, 
+  0.00043323036f, 0.00046138411f, 0.00049136745f, 0.00052329927f, 
+  0.00055730621f, 0.00059352311f, 0.00063209358f, 0.00067317058f, 
+  0.00071691700f, 0.00076350630f, 0.00081312324f, 0.00086596457f, 
+  0.00092223983f, 0.00098217216f, 0.0010459992f,  0.0011139742f, 
+  0.0011863665f,  0.0012634633f,  0.0013455702f,  0.0014330129f, 
+  0.0015261382f,  0.0016253153f,  0.0017309374f,  0.0018434235f, 
+  0.0019632195f,  0.0020908006f,  0.0022266726f,  0.0023713743f, 
+  0.0025254795f,  0.0026895994f,  0.0028643847f,  0.0030505286f, 
+  0.0032487691f,  0.0034598925f,  0.0036847358f,  0.0039241906f, 
+  0.0041792066f,  0.0044507950f,  0.0047400328f,  0.0050480668f, 
+  0.0053761186f,  0.0057254891f,  0.0060975636f,  0.0064938176f, 
+  0.0069158225f,  0.0073652516f,  0.0078438871f,  0.0083536271f, 
+  0.0088964928f,  0.009474637f,   0.010090352f,   0.010746080f, 
+  0.011444421f,   0.012188144f,   0.012980198f,   0.013823725f, 
+  0.014722068f,   0.015678791f,   0.016697687f,   0.017782797f, 
+  0.018938423f,   0.020169149f,   0.021479854f,   0.022875735f, 
+  0.024362330f,   0.025945531f,   0.027631618f,   0.029427276f, 
+  0.031339626f,   0.033376252f,   0.035545228f,   0.037855157f, 
+  0.040315199f,   0.042935108f,   0.045725273f,   0.048696758f, 
+  0.051861348f,   0.055231591f,   0.058820850f,   0.062643361f, 
+  0.066714279f,   0.071049749f,   0.075666962f,   0.080584227f, 
+  0.085821044f,   0.091398179f,   0.097337747f,   0.10366330f, 
+  0.11039993f,    0.11757434f,    0.12521498f,    0.13335215f, 
+  0.14201813f,    0.15124727f,    0.16107617f,    0.17154380f, 
+  0.18269168f,    0.19456402f,    0.20720788f,    0.22067342f, 
+  0.23501402f,    0.25028656f,    0.26655159f,    0.28387361f, 
+  0.30232132f,    0.32196786f,    0.34289114f,    0.36517414f, 
+  0.38890521f,    0.41417847f,    0.44109412f,    0.46975890f, 
+  0.50028648f,    0.53279791f,    0.56742212f,    0.60429640f, 
+  0.64356699f,    0.68538959f,    0.72993007f,    0.77736504f, 
+  0.82788260f,    0.88168307f,    0.9389798f,     1.0f
+};
+
+
+// @OPTIMIZE: if you want to replace this bresenham line-drawing routine,
+// note that you must produce bit-identical output to decode correctly;
+// this specific sequence of operations is specified in the spec (it's
+// drawing integer-quantized frequency-space lines that the encoder
+// expects to be exactly the same)
+//     ... also, isn't the whole point of Bresenham's algorithm to NOT
+// have to divide in the setup? sigh.
+#ifndef STB_VORBIS_NO_DEFER_FLOOR
+#define LINE_OP(a,b)   a *= b
+#else
+#define LINE_OP(a,b)   a = b
+#endif
+
+#ifdef STB_VORBIS_DIVIDE_TABLE
+#define DIVTAB_NUMER   32
+#define DIVTAB_DENOM   64
+int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]; // 2KB
+#endif
+
+static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n)
+{
+   int dy = y1 - y0;
+   int adx = x1 - x0;
+   int ady = abs(dy);
+   int base;
+   int x=x0,y=y0;
+   int err = 0;
+   int sy;
+
+#ifdef STB_VORBIS_DIVIDE_TABLE
+   if (adx < DIVTAB_DENOM && ady < DIVTAB_NUMER) {
+      if (dy < 0) {
+         base = -integer_divide_table[ady][adx];
+         sy = base-1;
+      } else {
+         base =  integer_divide_table[ady][adx];
+         sy = base+1;
+      }
+   } else {
+      base = dy / adx;
+      if (dy < 0)
+         sy = base - 1;
+      else
+         sy = base+1;
+   }
+#else
+   base = dy / adx;
+   if (dy < 0)
+      sy = base - 1;
+   else
+      sy = base+1;
+#endif
+   ady -= abs(base) * adx;
+   if (x1 > n) x1 = n;
+   LINE_OP(output[x], inverse_db_table[y]);
+   for (++x; x < x1; ++x) {
+      err += ady;
+      if (err >= adx) {
+         err -= adx;
+         y += sy;
+      } else
+         y += base;
+      LINE_OP(output[x], inverse_db_table[y]);
+   }
+}
+
+static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype)
+{
+   int k;
+   if (rtype == 0) {
+      int step = n / book->dimensions;
+      for (k=0; k < step; ++k)
+         if (!codebook_decode_step(f, book, target+offset+k, n-offset-k, step))
+            return FALSE;
+   } else {
+      for (k=0; k < n; ) {
+         if (!codebook_decode(f, book, target+offset, n-k))
+            return FALSE;
+         k += book->dimensions;
+         offset += book->dimensions;
+      }
+   }
+   return TRUE;
+}
+
+static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode)
+{
+   int i,j,pass;
+   Residue *r = f->residue_config + rn;
+   int rtype = f->residue_types[rn];
+   int c = r->classbook;
+   int classwords = f->codebooks[c].dimensions;
+   int n_read = r->end - r->begin;
+   int part_read = n_read / r->part_size;
+   int temp_alloc_point = temp_alloc_save(f);
+   #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+   uint8 ***part_classdata = (uint8 ***) temp_block_array(f,f->channels, part_read * sizeof(**part_classdata));
+   #else
+   int **classifications = (int **) temp_block_array(f,f->channels, part_read * sizeof(**classifications));
+   #endif
+
+   stb_prof(2);
+   for (i=0; i < ch; ++i)
+      if (!do_not_decode[i])
+         memset(residue_buffers[i], 0, sizeof(float) * n);
+
+   if (rtype == 2 && ch != 1) {
+      int len = ch * n;
+      for (j=0; j < ch; ++j)
+         if (!do_not_decode[j])
+            break;
+      if (j == ch)
+         goto done;
+
+      stb_prof(3);
+      for (pass=0; pass < 8; ++pass) {
+         int pcount = 0, class_set = 0;
+         if (ch == 2) {
+            stb_prof(13);
+            while (pcount < part_read) {
+               int z = r->begin + pcount*r->part_size;
+               int c_inter = (z & 1), p_inter = z>>1;
+               if (pass == 0) {
+                  Codebook *c = f->codebooks+r->classbook;
+                  int q;
+                  DECODE(q,f,c);
+                  if (q == EOP) goto done;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  part_classdata[0][class_set] = r->classdata[q];
+                  #else
+                  for (i=classwords-1; i >= 0; --i) {
+                     classifications[0][i+pcount] = q % r->classifications;
+                     q /= r->classifications;
+                  }
+                  #endif
+               }
+               stb_prof(5);
+               for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
+                  int z = r->begin + pcount*r->part_size;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  int c = part_classdata[0][class_set][i];
+                  #else
+                  int c = classifications[0][pcount];
+                  #endif
+                  int b = r->residue_books[c][pass];
+                  if (b >= 0) {
+                     Codebook *book = f->codebooks + b;
+                     stb_prof(20);  // accounts for X time
+                     #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
+                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
+                        goto done;
+                     #else
+                     // saves 1%
+                     if (!codebook_decode_deinterleave_repeat_2(f, book, residue_buffers, &c_inter, &p_inter, n, r->part_size))
+                        goto done;
+                     #endif
+                     stb_prof(7);
+                  } else {
+                     z += r->part_size;
+                     c_inter = z & 1;
+                     p_inter = z >> 1;
+                  }
+               }
+               stb_prof(8);
+               #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+               ++class_set;
+               #endif
+            }
+         } else if (ch == 1) {
+            while (pcount < part_read) {
+               int z = r->begin + pcount*r->part_size;
+               int c_inter = 0, p_inter = z;
+               if (pass == 0) {
+                  Codebook *c = f->codebooks+r->classbook;
+                  int q;
+                  DECODE(q,f,c);
+                  if (q == EOP) goto done;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  part_classdata[0][class_set] = r->classdata[q];
+                  #else
+                  for (i=classwords-1; i >= 0; --i) {
+                     classifications[0][i+pcount] = q % r->classifications;
+                     q /= r->classifications;
+                  }
+                  #endif
+               }
+               for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
+                  int z = r->begin + pcount*r->part_size;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  int c = part_classdata[0][class_set][i];
+                  #else
+                  int c = classifications[0][pcount];
+                  #endif
+                  int b = r->residue_books[c][pass];
+                  if (b >= 0) {
+                     Codebook *book = f->codebooks + b;
+                     stb_prof(22);
+                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
+                        goto done;
+                     stb_prof(3);
+                  } else {
+                     z += r->part_size;
+                     c_inter = 0;
+                     p_inter = z;
+                  }
+               }
+               #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+               ++class_set;
+               #endif
+            }
+         } else {
+            while (pcount < part_read) {
+               int z = r->begin + pcount*r->part_size;
+               int c_inter = z % ch, p_inter = z/ch;
+               if (pass == 0) {
+                  Codebook *c = f->codebooks+r->classbook;
+                  int q;
+                  DECODE(q,f,c);
+                  if (q == EOP) goto done;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  part_classdata[0][class_set] = r->classdata[q];
+                  #else
+                  for (i=classwords-1; i >= 0; --i) {
+                     classifications[0][i+pcount] = q % r->classifications;
+                     q /= r->classifications;
+                  }
+                  #endif
+               }
+               for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
+                  int z = r->begin + pcount*r->part_size;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  int c = part_classdata[0][class_set][i];
+                  #else
+                  int c = classifications[0][pcount];
+                  #endif
+                  int b = r->residue_books[c][pass];
+                  if (b >= 0) {
+                     Codebook *book = f->codebooks + b;
+                     stb_prof(22);
+                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
+                        goto done;
+                     stb_prof(3);
+                  } else {
+                     z += r->part_size;
+                     c_inter = z % ch;
+                     p_inter = z / ch;
+                  }
+               }
+               #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+               ++class_set;
+               #endif
+            }
+         }
+      }
+      goto done;
+   }
+   stb_prof(9);
+
+   for (pass=0; pass < 8; ++pass) {
+      int pcount = 0, class_set=0;
+      while (pcount < part_read) {
+         if (pass == 0) {
+            for (j=0; j < ch; ++j) {
+               if (!do_not_decode[j]) {
+                  Codebook *c = f->codebooks+r->classbook;
+                  int temp;
+                  DECODE(temp,f,c);
+                  if (temp == EOP) goto done;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  part_classdata[j][class_set] = r->classdata[temp];
+                  #else
+                  for (i=classwords-1; i >= 0; --i) {
+                     classifications[j][i+pcount] = temp % r->classifications;
+                     temp /= r->classifications;
+                  }
+                  #endif
+               }
+            }
+         }
+         for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
+            for (j=0; j < ch; ++j) {
+               if (!do_not_decode[j]) {
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  int c = part_classdata[j][class_set][i];
+                  #else
+                  int c = classifications[j][pcount];
+                  #endif
+                  int b = r->residue_books[c][pass];
+                  if (b >= 0) {
+                     float *target = residue_buffers[j];
+                     int offset = r->begin + pcount * r->part_size;
+                     int n = r->part_size;
+                     Codebook *book = f->codebooks + b;
+                     if (!residue_decode(f, book, target, offset, n, rtype))
+                        goto done;
+                  }
+               }
+            }
+         }
+         #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+         ++class_set;
+         #endif
+      }
+   }
+  done:
+   stb_prof(0);
+   temp_alloc_restore(f,temp_alloc_point);
+}
+
+
+#if 0
+// slow way for debugging
+void inverse_mdct_slow(float *buffer, int n)
+{
+   int i,j;
+   int n2 = n >> 1;
+   float *x = (float *) malloc(sizeof(*x) * n2);
+   memcpy(x, buffer, sizeof(*x) * n2);
+   for (i=0; i < n; ++i) {
+      float acc = 0;
+      for (j=0; j < n2; ++j)
+         // formula from paper:
+         //acc += n/4.0f * x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1));
+         // formula from wikipedia
+         //acc += 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5));
+         // these are equivalent, except the formula from the paper inverts the multiplier!
+         // however, what actually works is NO MULTIPLIER!?!
+         //acc += 64 * 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5));
+         acc += x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1));
+      buffer[i] = acc;
+   }
+   free(x);
+}
+#elif 0
+// same as above, but just barely able to run in real time on modern machines
+void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype)
+{
+   float mcos[16384];
+   int i,j;
+   int n2 = n >> 1, nmask = (n << 2) -1;
+   float *x = (float *) malloc(sizeof(*x) * n2);
+   memcpy(x, buffer, sizeof(*x) * n2);
+   for (i=0; i < 4*n; ++i)
+      mcos[i] = (float) cos(M_PI / 2 * i / n);
+
+   for (i=0; i < n; ++i) {
+      float acc = 0;
+      for (j=0; j < n2; ++j)
+         acc += x[j] * mcos[(2 * i + 1 + n2)*(2*j+1) & nmask];
+      buffer[i] = acc;
+   }
+   free(x);
+}
+#else
+// transform to use a slow dct-iv; this is STILL basically trivial,
+// but only requires half as many ops
+void dct_iv_slow(float *buffer, int n)
+{
+   float mcos[16384];
+   float x[2048];
+   int i,j;
+   int n2 = n >> 1, nmask = (n << 3) - 1;
+   memcpy(x, buffer, sizeof(*x) * n);
+   for (i=0; i < 8*n; ++i)
+      mcos[i] = (float) cos(M_PI / 4 * i / n);
+   for (i=0; i < n; ++i) {
+      float acc = 0;
+      for (j=0; j < n; ++j)
+         acc += x[j] * mcos[((2 * i + 1)*(2*j+1)) & nmask];
+         //acc += x[j] * cos(M_PI / n * (i + 0.5) * (j + 0.5));
+      buffer[i] = acc;
+   }
+   free(x);
+}
+
+void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype)
+{
+   int i, n4 = n >> 2, n2 = n >> 1, n3_4 = n - n4;
+   float temp[4096];
+
+   memcpy(temp, buffer, n2 * sizeof(float));
+   dct_iv_slow(temp, n2);  // returns -c'-d, a-b'
+
+   for (i=0; i < n4  ; ++i) buffer[i] = temp[i+n4];            // a-b'
+   for (   ; i < n3_4; ++i) buffer[i] = -temp[n3_4 - i - 1];   // b-a', c+d'
+   for (   ; i < n   ; ++i) buffer[i] = -temp[i - n3_4];       // c'+d
+}
+#endif
+
+#ifndef LIBVORBIS_MDCT
+#define LIBVORBIS_MDCT 0
+#endif
+
+#if LIBVORBIS_MDCT
+// directly call the vorbis MDCT using an interface documented
+// by Jeff Roberts... useful for performance comparison
+typedef struct 
+{
+  int n;
+  int log2n;
+  
+  float *trig;
+  int   *bitrev;
+
+  float scale;
+} mdct_lookup;
+
+extern void mdct_init(mdct_lookup *lookup, int n);
+extern void mdct_clear(mdct_lookup *l);
+extern void mdct_backward(mdct_lookup *init, float *in, float *out);
+
+mdct_lookup M1,M2;
+
+void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)
+{
+   mdct_lookup *M;
+   if (M1.n == n) M = &M1;
+   else if (M2.n == n) M = &M2;
+   else if (M1.n == 0) { mdct_init(&M1, n); M = &M1; }
+   else { 
+      if (M2.n) __asm int 3;
+      mdct_init(&M2, n);
+      M = &M2;
+   }
+
+   mdct_backward(M, buffer, buffer);
+}
+#endif
+
+
+// the following were split out into separate functions while optimizing;
+// they could be pushed back up but eh. __forceinline showed no change;
+// they're probably already being inlined.
+static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A)
+{
+   float *ee0 = e + i_off;
+   float *ee2 = ee0 + k_off;
+   int i;
+
+   assert((n & 3) == 0);
+   for (i=(n>>2); i > 0; --i) {
+      float k00_20, k01_21;
+      k00_20  = ee0[ 0] - ee2[ 0];
+      k01_21  = ee0[-1] - ee2[-1];
+      ee0[ 0] += ee2[ 0];//ee0[ 0] = ee0[ 0] + ee2[ 0];
+      ee0[-1] += ee2[-1];//ee0[-1] = ee0[-1] + ee2[-1];
+      ee2[ 0] = k00_20 * A[0] - k01_21 * A[1];
+      ee2[-1] = k01_21 * A[0] + k00_20 * A[1];
+      A += 8;
+
+      k00_20  = ee0[-2] - ee2[-2];
+      k01_21  = ee0[-3] - ee2[-3];
+      ee0[-2] += ee2[-2];//ee0[-2] = ee0[-2] + ee2[-2];
+      ee0[-3] += ee2[-3];//ee0[-3] = ee0[-3] + ee2[-3];
+      ee2[-2] = k00_20 * A[0] - k01_21 * A[1];
+      ee2[-3] = k01_21 * A[0] + k00_20 * A[1];
+      A += 8;
+
+      k00_20  = ee0[-4] - ee2[-4];
+      k01_21  = ee0[-5] - ee2[-5];
+      ee0[-4] += ee2[-4];//ee0[-4] = ee0[-4] + ee2[-4];
+      ee0[-5] += ee2[-5];//ee0[-5] = ee0[-5] + ee2[-5];
+      ee2[-4] = k00_20 * A[0] - k01_21 * A[1];
+      ee2[-5] = k01_21 * A[0] + k00_20 * A[1];
+      A += 8;
+
+      k00_20  = ee0[-6] - ee2[-6];
+      k01_21  = ee0[-7] - ee2[-7];
+      ee0[-6] += ee2[-6];//ee0[-6] = ee0[-6] + ee2[-6];
+      ee0[-7] += ee2[-7];//ee0[-7] = ee0[-7] + ee2[-7];
+      ee2[-6] = k00_20 * A[0] - k01_21 * A[1];
+      ee2[-7] = k01_21 * A[0] + k00_20 * A[1];
+      A += 8;
+      ee0 -= 8;
+      ee2 -= 8;
+   }
+}
+
+static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1)
+{
+   int i;
+   float k00_20, k01_21;
+
+   float *e0 = e + d0;
+   float *e2 = e0 + k_off;
+
+   for (i=lim >> 2; i > 0; --i) {
+      k00_20 = e0[-0] - e2[-0];
+      k01_21 = e0[-1] - e2[-1];
+      e0[-0] += e2[-0];//e0[-0] = e0[-0] + e2[-0];
+      e0[-1] += e2[-1];//e0[-1] = e0[-1] + e2[-1];
+      e2[-0] = (k00_20)*A[0] - (k01_21) * A[1];
+      e2[-1] = (k01_21)*A[0] + (k00_20) * A[1];
+
+      A += k1;
+
+      k00_20 = e0[-2] - e2[-2];
+      k01_21 = e0[-3] - e2[-3];
+      e0[-2] += e2[-2];//e0[-2] = e0[-2] + e2[-2];
+      e0[-3] += e2[-3];//e0[-3] = e0[-3] + e2[-3];
+      e2[-2] = (k00_20)*A[0] - (k01_21) * A[1];
+      e2[-3] = (k01_21)*A[0] + (k00_20) * A[1];
+
+      A += k1;
+
+      k00_20 = e0[-4] - e2[-4];
+      k01_21 = e0[-5] - e2[-5];
+      e0[-4] += e2[-4];//e0[-4] = e0[-4] + e2[-4];
+      e0[-5] += e2[-5];//e0[-5] = e0[-5] + e2[-5];
+      e2[-4] = (k00_20)*A[0] - (k01_21) * A[1];
+      e2[-5] = (k01_21)*A[0] + (k00_20) * A[1];
+
+      A += k1;
+
+      k00_20 = e0[-6] - e2[-6];
+      k01_21 = e0[-7] - e2[-7];
+      e0[-6] += e2[-6];//e0[-6] = e0[-6] + e2[-6];
+      e0[-7] += e2[-7];//e0[-7] = e0[-7] + e2[-7];
+      e2[-6] = (k00_20)*A[0] - (k01_21) * A[1];
+      e2[-7] = (k01_21)*A[0] + (k00_20) * A[1];
+
+      e0 -= 8;
+      e2 -= 8;
+
+      A += k1;
+   }
+}
+
+static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0)
+{
+   int i;
+   float A0 = A[0];
+   float A1 = A[0+1];
+   float A2 = A[0+a_off];
+   float A3 = A[0+a_off+1];
+   float A4 = A[0+a_off*2+0];
+   float A5 = A[0+a_off*2+1];
+   float A6 = A[0+a_off*3+0];
+   float A7 = A[0+a_off*3+1];
+
+   float k00,k11;
+
+   float *ee0 = e  +i_off;
+   float *ee2 = ee0+k_off;
+
+   for (i=n; i > 0; --i) {
+      k00     = ee0[ 0] - ee2[ 0];
+      k11     = ee0[-1] - ee2[-1];
+      ee0[ 0] =  ee0[ 0] + ee2[ 0];
+      ee0[-1] =  ee0[-1] + ee2[-1];
+      ee2[ 0] = (k00) * A0 - (k11) * A1;
+      ee2[-1] = (k11) * A0 + (k00) * A1;
+
+      k00     = ee0[-2] - ee2[-2];
+      k11     = ee0[-3] - ee2[-3];
+      ee0[-2] =  ee0[-2] + ee2[-2];
+      ee0[-3] =  ee0[-3] + ee2[-3];
+      ee2[-2] = (k00) * A2 - (k11) * A3;
+      ee2[-3] = (k11) * A2 + (k00) * A3;
+
+      k00     = ee0[-4] - ee2[-4];
+      k11     = ee0[-5] - ee2[-5];
+      ee0[-4] =  ee0[-4] + ee2[-4];
+      ee0[-5] =  ee0[-5] + ee2[-5];
+      ee2[-4] = (k00) * A4 - (k11) * A5;
+      ee2[-5] = (k11) * A4 + (k00) * A5;
+
+      k00     = ee0[-6] - ee2[-6];
+      k11     = ee0[-7] - ee2[-7];
+      ee0[-6] =  ee0[-6] + ee2[-6];
+      ee0[-7] =  ee0[-7] + ee2[-7];
+      ee2[-6] = (k00) * A6 - (k11) * A7;
+      ee2[-7] = (k11) * A6 + (k00) * A7;
+
+      ee0 -= k0;
+      ee2 -= k0;
+   }
+}
+
+static __forceinline void iter_54(float *z)
+{
+   float k00,k11,k22,k33;
+   float y0,y1,y2,y3;
+
+   k00  = z[ 0] - z[-4];
+   y0   = z[ 0] + z[-4];
+   y2   = z[-2] + z[-6];
+   k22  = z[-2] - z[-6];
+
+   z[-0] = y0 + y2;      // z0 + z4 + z2 + z6
+   z[-2] = y0 - y2;      // z0 + z4 - z2 - z6
+
+   // done with y0,y2
+
+   k33  = z[-3] - z[-7];
+
+   z[-4] = k00 + k33;    // z0 - z4 + z3 - z7
+   z[-6] = k00 - k33;    // z0 - z4 - z3 + z7
+
+   // done with k33
+
+   k11  = z[-1] - z[-5];
+   y1   = z[-1] + z[-5];
+   y3   = z[-3] + z[-7];
+
+   z[-1] = y1 + y3;      // z1 + z5 + z3 + z7
+   z[-3] = y1 - y3;      // z1 + z5 - z3 - z7
+   z[-5] = k11 - k22;    // z1 - z5 + z2 - z6
+   z[-7] = k11 + k22;    // z1 - z5 - z2 + z6
+}
+
+static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n)
+{
+   int k_off = -8;
+   int a_off = base_n >> 3;
+   float A2 = A[0+a_off];
+   float *z = e + i_off;
+   float *base = z - 16 * n;
+
+   while (z > base) {
+      float k00,k11;
+
+      k00   = z[-0] - z[-8];
+      k11   = z[-1] - z[-9];
+      z[-0] = z[-0] + z[-8];
+      z[-1] = z[-1] + z[-9];
+      z[-8] =  k00;
+      z[-9] =  k11 ;
+
+      k00    = z[ -2] - z[-10];
+      k11    = z[ -3] - z[-11];
+      z[ -2] = z[ -2] + z[-10];
+      z[ -3] = z[ -3] + z[-11];
+      z[-10] = (k00+k11) * A2;
+      z[-11] = (k11-k00) * A2;
+
+      k00    = z[-12] - z[ -4];  // reverse to avoid a unary negation
+      k11    = z[ -5] - z[-13];
+      z[ -4] = z[ -4] + z[-12];
+      z[ -5] = z[ -5] + z[-13];
+      z[-12] = k11;
+      z[-13] = k00;
+
+      k00    = z[-14] - z[ -6];  // reverse to avoid a unary negation
+      k11    = z[ -7] - z[-15];
+      z[ -6] = z[ -6] + z[-14];
+      z[ -7] = z[ -7] + z[-15];
+      z[-14] = (k00+k11) * A2;
+      z[-15] = (k00-k11) * A2;
+
+      iter_54(z);
+      iter_54(z-8);
+      z -= 16;
+   }
+}
+
+static void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)
+{
+   int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l;
+   int n3_4 = n - n4, ld;
+   // @OPTIMIZE: reduce register pressure by using fewer variables?
+   int save_point = temp_alloc_save(f);
+   float *buf2 = (float *) temp_alloc(f, n2 * sizeof(*buf2));
+   float *u=NULL,*v=NULL;
+   // twiddle factors
+   float *A = f->A[blocktype];
+
+   // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio"
+   // See notes about bugs in that paper in less-optimal implementation 'inverse_mdct_old' after this function.
+
+   // kernel from paper
+
+
+   // merged:
+   //   copy and reflect spectral data
+   //   step 0
+
+   // note that it turns out that the items added together during
+   // this step are, in fact, being added to themselves (as reflected
+   // by step 0). inexplicable inefficiency! this became obvious
+   // once I combined the passes.
+
+   // so there's a missing 'times 2' here (for adding X to itself).
+   // this propogates through linearly to the end, where the numbers
+   // are 1/2 too small, and need to be compensated for.
+
+   {
+      float *d,*e, *AA, *e_stop;
+      d = &buf2[n2-2];
+      AA = A;
+      e = &buffer[0];
+      e_stop = &buffer[n2];
+      while (e != e_stop) {
+         d[1] = (e[0] * AA[0] - e[2]*AA[1]);
+         d[0] = (e[0] * AA[1] + e[2]*AA[0]);
+         d -= 2;
+         AA += 2;
+         e += 4;
+      }
+
+      e = &buffer[n2-3];
+      while (d >= buf2) {
+         d[1] = (-e[2] * AA[0] - -e[0]*AA[1]);
+         d[0] = (-e[2] * AA[1] + -e[0]*AA[0]);
+         d -= 2;
+         AA += 2;
+         e -= 4;
+      }
+   }
+
+   // now we use symbolic names for these, so that we can
+   // possibly swap their meaning as we change which operations
+   // are in place
+
+   u = buffer;
+   v = buf2;
+
+   // step 2    (paper output is w, now u)
+   // this could be in place, but the data ends up in the wrong
+   // place... _somebody_'s got to swap it, so this is nominated
+   {
+      float *AA = &A[n2-8];
+      float *d0,*d1, *e0, *e1;
+
+      e0 = &v[n4];
+      e1 = &v[0];
+
+      d0 = &u[n4];
+      d1 = &u[0];
+
+      while (AA >= A) {
+         float v40_20, v41_21;
+
+         v41_21 = e0[1] - e1[1];
+         v40_20 = e0[0] - e1[0];
+         d0[1]  = e0[1] + e1[1];
+         d0[0]  = e0[0] + e1[0];
+         d1[1]  = v41_21*AA[4] - v40_20*AA[5];
+         d1[0]  = v40_20*AA[4] + v41_21*AA[5];
+
+         v41_21 = e0[3] - e1[3];
+         v40_20 = e0[2] - e1[2];
+         d0[3]  = e0[3] + e1[3];
+         d0[2]  = e0[2] + e1[2];
+         d1[3]  = v41_21*AA[0] - v40_20*AA[1];
+         d1[2]  = v40_20*AA[0] + v41_21*AA[1];
+
+         AA -= 8;
+
+         d0 += 4;
+         d1 += 4;
+         e0 += 4;
+         e1 += 4;
+      }
+   }
+
+   // step 3
+   ld = ilog(n) - 1; // ilog is off-by-one from normal definitions
+
+   // optimized step 3:
+
+   // the original step3 loop can be nested r inside s or s inside r;
+   // it's written originally as s inside r, but this is dumb when r
+   // iterates many times, and s few. So I have two copies of it and
+   // switch between them halfway.
+
+   // this is iteration 0 of step 3
+   imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*0, -(n >> 3), A);
+   imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*1, -(n >> 3), A);
+
+   // this is iteration 1 of step 3
+   imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*0, -(n >> 4), A, 16);
+   imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*1, -(n >> 4), A, 16);
+   imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*2, -(n >> 4), A, 16);
+   imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*3, -(n >> 4), A, 16);
+
+   l=2;
+   for (; l < (ld-3)>>1; ++l) {
+      int k0 = n >> (l+2), k0_2 = k0>>1;
+      int lim = 1 << (l+1);
+      int i;
+      for (i=0; i < lim; ++i)
+         imdct_step3_inner_r_loop(n >> (l+4), u, n2-1 - k0*i, -k0_2, A, 1 << (l+3));
+   }
+
+   for (; l < ld-6; ++l) {
+      int k0 = n >> (l+2), k1 = 1 << (l+3), k0_2 = k0>>1;
+      int rlim = n >> (l+6), r;
+      int lim = 1 << (l+1);
+      int i_off;
+      float *A0 = A;
+      i_off = n2-1;
+      for (r=rlim; r > 0; --r) {
+         imdct_step3_inner_s_loop(lim, u, i_off, -k0_2, A0, k1, k0);
+         A0 += k1*4;
+         i_off -= 8;
+      }
+   }
+
+   // iterations with count:
+   //   ld-6,-5,-4 all interleaved together
+   //       the big win comes from getting rid of needless flops
+   //         due to the constants on pass 5 & 4 being all 1 and 0;
+   //       combining them to be simultaneous to improve cache made little difference
+   imdct_step3_inner_s_loop_ld654(n >> 5, u, n2-1, A, n);
+
+   // output is u
+
+   // step 4, 5, and 6
+   // cannot be in-place because of step 5
+   {
+      uint16 *bitrev = f->bit_reverse[blocktype];
+      // weirdly, I'd have thought reading sequentially and writing
+      // erratically would have been better than vice-versa, but in
+      // fact that's not what my testing showed. (That is, with
+      // j = bitreverse(i), do you read i and write j, or read j and write i.)
+
+      float *d0 = &v[n4-4];
+      float *d1 = &v[n2-4];
+      while (d0 >= v) {
+         int k4;
+
+         k4 = bitrev[0];
+         d1[3] = u[k4+0];
+         d1[2] = u[k4+1];
+         d0[3] = u[k4+2];
+         d0[2] = u[k4+3];
+
+         k4 = bitrev[1];
+         d1[1] = u[k4+0];
+         d1[0] = u[k4+1];
+         d0[1] = u[k4+2];
+         d0[0] = u[k4+3];
+         
+         d0 -= 4;
+         d1 -= 4;
+         bitrev += 2;
+      }
+   }
+   // (paper output is u, now v)
+
+
+   // data must be in buf2
+   assert(v == buf2);
+
+   // step 7   (paper output is v, now v)
+   // this is now in place
+   {
+      float *C = f->C[blocktype];
+      float *d, *e;
+
+      d = v;
+      e = v + n2 - 4;
+
+      while (d < e) {
+         float a02,a11,b0,b1,b2,b3;
+
+         a02 = d[0] - e[2];
+         a11 = d[1] + e[3];
+
+         b0 = C[1]*a02 + C[0]*a11;
+         b1 = C[1]*a11 - C[0]*a02;
+
+         b2 = d[0] + e[ 2];
+         b3 = d[1] - e[ 3];
+
+         d[0] = b2 + b0;
+         d[1] = b3 + b1;
+         e[2] = b2 - b0;
+         e[3] = b1 - b3;
+
+         a02 = d[2] - e[0];
+         a11 = d[3] + e[1];
+
+         b0 = C[3]*a02 + C[2]*a11;
+         b1 = C[3]*a11 - C[2]*a02;
+
+         b2 = d[2] + e[ 0];
+         b3 = d[3] - e[ 1];
+
+         d[2] = b2 + b0;
+         d[3] = b3 + b1;
+         e[0] = b2 - b0;
+         e[1] = b1 - b3;
+
+         C += 4;
+         d += 4;
+         e -= 4;
+      }
+   }
+
+   // data must be in buf2
+
+
+   // step 8+decode   (paper output is X, now buffer)
+   // this generates pairs of data a la 8 and pushes them directly through
+   // the decode kernel (pushing rather than pulling) to avoid having
+   // to make another pass later
+
+   // this cannot POSSIBLY be in place, so we refer to the buffers directly
+
+   {
+      float *d0,*d1,*d2,*d3;
+
+      float *B = f->B[blocktype] + n2 - 8;
+      float *e = buf2 + n2 - 8;
+      d0 = &buffer[0];
+      d1 = &buffer[n2-4];
+      d2 = &buffer[n2];
+      d3 = &buffer[n-4];
+      while (e >= v) {
+         float p0,p1,p2,p3;
+
+         p3 =  e[6]*B[7] - e[7]*B[6];
+         p2 = -e[6]*B[6] - e[7]*B[7]; 
+
+         d0[0] =   p3;
+         d1[3] = - p3;
+         d2[0] =   p2;
+         d3[3] =   p2;
+
+         p1 =  e[4]*B[5] - e[5]*B[4];
+         p0 = -e[4]*B[4] - e[5]*B[5]; 
+
+         d0[1] =   p1;
+         d1[2] = - p1;
+         d2[1] =   p0;
+         d3[2] =   p0;
+
+         p3 =  e[2]*B[3] - e[3]*B[2];
+         p2 = -e[2]*B[2] - e[3]*B[3]; 
+
+         d0[2] =   p3;
+         d1[1] = - p3;
+         d2[2] =   p2;
+         d3[1] =   p2;
+
+         p1 =  e[0]*B[1] - e[1]*B[0];
+         p0 = -e[0]*B[0] - e[1]*B[1]; 
+
+         d0[3] =   p1;
+         d1[0] = - p1;
+         d2[3] =   p0;
+         d3[0] =   p0;
+
+         B -= 8;
+         e -= 8;
+         d0 += 4;
+         d2 += 4;
+         d1 -= 4;
+         d3 -= 4;
+      }
+   }
+
+   temp_alloc_restore(f,save_point);
+}
+
+#if 0
+// this is the original version of the above code, if you want to optimize it from scratch
+void inverse_mdct_naive(float *buffer, int n)
+{
+   float s;
+   float A[1 << 12], B[1 << 12], C[1 << 11];
+   int i,k,k2,k4, n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l;
+   int n3_4 = n - n4, ld;
+   // how can they claim this only uses N words?!
+   // oh, because they're only used sparsely, whoops
+   float u[1 << 13], X[1 << 13], v[1 << 13], w[1 << 13];
+   // set up twiddle factors
+
+   for (k=k2=0; k < n4; ++k,k2+=2) {
+      A[k2  ] = (float)  cos(4*k*M_PI/n);
+      A[k2+1] = (float) -sin(4*k*M_PI/n);
+      B[k2  ] = (float)  cos((k2+1)*M_PI/n/2);
+      B[k2+1] = (float)  sin((k2+1)*M_PI/n/2);
+   }
+   for (k=k2=0; k < n8; ++k,k2+=2) {
+      C[k2  ] = (float)  cos(2*(k2+1)*M_PI/n);
+      C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n);
+   }
+
+   // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio"
+   // Note there are bugs in that pseudocode, presumably due to them attempting
+   // to rename the arrays nicely rather than representing the way their actual
+   // implementation bounces buffers back and forth. As a result, even in the
+   // "some formulars corrected" version, a direct implementation fails. These
+   // are noted below as "paper bug".
+
+   // copy and reflect spectral data
+   for (k=0; k < n2; ++k) u[k] = buffer[k];
+   for (   ; k < n ; ++k) u[k] = -buffer[n - k - 1];
+   // kernel from paper
+   // step 1
+   for (k=k2=k4=0; k < n4; k+=1, k2+=2, k4+=4) {
+      v[n-k4-1] = (u[k4] - u[n-k4-1]) * A[k2]   - (u[k4+2] - u[n-k4-3])*A[k2+1];
+      v[n-k4-3] = (u[k4] - u[n-k4-1]) * A[k2+1] + (u[k4+2] - u[n-k4-3])*A[k2];
+   }
+   // step 2
+   for (k=k4=0; k < n8; k+=1, k4+=4) {
+      w[n2+3+k4] = v[n2+3+k4] + v[k4+3];
+      w[n2+1+k4] = v[n2+1+k4] + v[k4+1];
+      w[k4+3]    = (v[n2+3+k4] - v[k4+3])*A[n2-4-k4] - (v[n2+1+k4]-v[k4+1])*A[n2-3-k4];
+      w[k4+1]    = (v[n2+1+k4] - v[k4+1])*A[n2-4-k4] + (v[n2+3+k4]-v[k4+3])*A[n2-3-k4];
+   }
+   // step 3
+   ld = ilog(n) - 1; // ilog is off-by-one from normal definitions
+   for (l=0; l < ld-3; ++l) {
+      int k0 = n >> (l+2), k1 = 1 << (l+3);
+      int rlim = n >> (l+4), r4, r;
+      int s2lim = 1 << (l+2), s2;
+      for (r=r4=0; r < rlim; r4+=4,++r) {
+         for (s2=0; s2 < s2lim; s2+=2) {
+            u[n-1-k0*s2-r4] = w[n-1-k0*s2-r4] + w[n-1-k0*(s2+1)-r4];
+            u[n-3-k0*s2-r4] = w[n-3-k0*s2-r4] + w[n-3-k0*(s2+1)-r4];
+            u[n-1-k0*(s2+1)-r4] = (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1]
+                                - (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1+1];
+            u[n-3-k0*(s2+1)-r4] = (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1]
+                                + (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1+1];
+         }
+      }
+      if (l+1 < ld-3) {
+         // paper bug: ping-ponging of u&w here is omitted
+         memcpy(w, u, sizeof(u));
+      }
+   }
+
+   // step 4
+   for (i=0; i < n8; ++i) {
+      int j = bit_reverse(i) >> (32-ld+3);
+      assert(j < n8);
+      if (i == j) {
+         // paper bug: original code probably swapped in place; if copying,
+         //            need to directly copy in this case
+         int i8 = i << 3;
+         v[i8+1] = u[i8+1];
+         v[i8+3] = u[i8+3];
+         v[i8+5] = u[i8+5];
+         v[i8+7] = u[i8+7];
+      } else if (i < j) {
+         int i8 = i << 3, j8 = j << 3;
+         v[j8+1] = u[i8+1], v[i8+1] = u[j8 + 1];
+         v[j8+3] = u[i8+3], v[i8+3] = u[j8 + 3];
+         v[j8+5] = u[i8+5], v[i8+5] = u[j8 + 5];
+         v[j8+7] = u[i8+7], v[i8+7] = u[j8 + 7];
+      }
+   }
+   // step 5
+   for (k=0; k < n2; ++k) {
+      w[k] = v[k*2+1];
+   }
+   // step 6
+   for (k=k2=k4=0; k < n8; ++k, k2 += 2, k4 += 4) {
+      u[n-1-k2] = w[k4];
+      u[n-2-k2] = w[k4+1];
+      u[n3_4 - 1 - k2] = w[k4+2];
+      u[n3_4 - 2 - k2] = w[k4+3];
+   }
+   // step 7
+   for (k=k2=0; k < n8; ++k, k2 += 2) {
+      v[n2 + k2 ] = ( u[n2 + k2] + u[n-2-k2] + C[k2+1]*(u[n2+k2]-u[n-2-k2]) + C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2;
+      v[n-2 - k2] = ( u[n2 + k2] + u[n-2-k2] - C[k2+1]*(u[n2+k2]-u[n-2-k2]) - C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2;
+      v[n2+1+ k2] = ( u[n2+1+k2] - u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2;
+      v[n-1 - k2] = (-u[n2+1+k2] + u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2;
+   }
+   // step 8
+   for (k=k2=0; k < n4; ++k,k2 += 2) {
+      X[k]      = v[k2+n2]*B[k2  ] + v[k2+1+n2]*B[k2+1];
+      X[n2-1-k] = v[k2+n2]*B[k2+1] - v[k2+1+n2]*B[k2  ];
+   }
+
+   // decode kernel to output
+   // determined the following value experimentally
+   // (by first figuring out what made inverse_mdct_slow work); then matching that here
+   // (probably vorbis encoder premultiplies by n or n/2, to save it on the decoder?)
+   s = 0.5; // theoretically would be n4
+
+   // [[[ note! the s value of 0.5 is compensated for by the B[] in the current code,
+   //     so it needs to use the "old" B values to behave correctly, or else
+   //     set s to 1.0 ]]]
+   for (i=0; i < n4  ; ++i) buffer[i] = s * X[i+n4];
+   for (   ; i < n3_4; ++i) buffer[i] = -s * X[n3_4 - i - 1];
+   for (   ; i < n   ; ++i) buffer[i] = -s * X[i - n3_4];
+}
+#endif
+
+static float *get_window(vorb *f, int len)
+{
+   len <<= 1;
+   if (len == f->blocksize_0) return f->window[0];
+   if (len == f->blocksize_1) return f->window[1];
+   assert(0);
+   return NULL;
+}
+
+#ifndef STB_VORBIS_NO_DEFER_FLOOR
+typedef int16 YTYPE;
+#else
+typedef int YTYPE;
+#endif
+static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag)
+{
+   int n2 = n >> 1;
+   int s = map->chan[i].mux, floor;
+   floor = map->submap_floor[s];
+   if (f->floor_types[floor] == 0) {
+      return error(f, VORBIS_invalid_stream);
+   } else {
+      Floor1 *g = &f->floor_config[floor].floor1;
+      int j,q;
+      int lx = 0, ly = finalY[0] * g->floor1_multiplier;
+      for (q=1; q < g->values; ++q) {
+         j = g->sorted_order[q];
+         #ifndef STB_VORBIS_NO_DEFER_FLOOR
+         if (finalY[j] >= 0)
+         #else
+         if (step2_flag[j])
+         #endif
+         {
+            int hy = finalY[j] * g->floor1_multiplier;
+            int hx = g->Xlist[j];
+            draw_line(target, lx,ly, hx,hy, n2);
+            lx = hx, ly = hy;
+         }
+      }
+      if (lx < n2)
+         // optimization of: draw_line(target, lx,ly, n,ly, n2);
+         for (j=lx; j < n2; ++j)
+            LINE_OP(target[j], inverse_db_table[ly]);
+   }
+   return TRUE;
+}
+
+static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)
+{
+   Mode *m;
+   int i, n, prev, next, window_center;
+   f->channel_buffer_start = f->channel_buffer_end = 0;
+
+  retry:
+   if (f->eof) return FALSE;
+   if (!maybe_start_packet(f))
+      return FALSE;
+   // check packet type
+   if (get_bits(f,1) != 0) {
+      if (IS_PUSH_MODE(f))
+         return error(f,VORBIS_bad_packet_type);
+      while (EOP != get8_packet(f));
+      goto retry;
+   }
+
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+
+   i = get_bits(f, ilog(f->mode_count-1));
+   if (i == EOP) return FALSE;
+   if (i >= f->mode_count) return FALSE;
+   *mode = i;
+   m = f->mode_config + i;
+   if (m->blockflag) {
+      n = f->blocksize_1;
+      prev = get_bits(f,1);
+      next = get_bits(f,1);
+   } else {
+      prev = next = 0;
+      n = f->blocksize_0;
+   }
+
+// WINDOWING
+
+   window_center = n >> 1;
+   if (m->blockflag && !prev) {
+      *p_left_start = (n - f->blocksize_0) >> 2;
+      *p_left_end   = (n + f->blocksize_0) >> 2;
+   } else {
+      *p_left_start = 0;
+      *p_left_end   = window_center;
+   }
+   if (m->blockflag && !next) {
+      *p_right_start = (n*3 - f->blocksize_0) >> 2;
+      *p_right_end   = (n*3 + f->blocksize_0) >> 2;
+   } else {
+      *p_right_start = window_center;
+      *p_right_end   = n;
+   }
+   return TRUE;
+}
+
+static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left)
+{
+   Mapping *map;
+   int i,j,k,n,n2;
+   int zero_channel[256];
+   int really_zero_channel[256];
+   int window_center;
+
+// WINDOWING
+
+   n = f->blocksize[m->blockflag];
+   window_center = n >> 1;
+
+   map = &f->mapping[m->mapping];
+
+// FLOORS
+   n2 = n >> 1;
+
+   stb_prof(1);
+   for (i=0; i < f->channels; ++i) {
+      int s = map->chan[i].mux, floor;
+      zero_channel[i] = FALSE;
+      floor = map->submap_floor[s];
+      if (f->floor_types[floor] == 0) {
+         return error(f, VORBIS_invalid_stream);
+      } else {
+         Floor1 *g = &f->floor_config[floor].floor1;
+         if (get_bits(f, 1)) {
+            short *finalY;
+            uint8 step2_flag[256];
+            static int range_list[4] = { 256, 128, 86, 64 };
+            int range = range_list[g->floor1_multiplier-1];
+            int offset = 2;
+            finalY = f->finalY[i];
+            finalY[0] = get_bits(f, ilog(range)-1);
+            finalY[1] = get_bits(f, ilog(range)-1);
+            for (j=0; j < g->partitions; ++j) {
+               int pclass = g->partition_class_list[j];
+               int cdim = g->class_dimensions[pclass];
+               int cbits = g->class_subclasses[pclass];
+               int csub = (1 << cbits)-1;
+               int cval = 0;
+               if (cbits) {
+                  Codebook *c = f->codebooks + g->class_masterbooks[pclass];
+                  DECODE(cval,f,c);
+               }
+               for (k=0; k < cdim; ++k) {
+                  int book = g->subclass_books[pclass][cval & csub];
+                  cval = cval >> cbits;
+                  if (book >= 0) {
+                     int temp;
+                     Codebook *c = f->codebooks + book;
+                     DECODE(temp,f,c);
+                     finalY[offset++] = temp;
+                  } else
+                     finalY[offset++] = 0;
+               }
+            }
+            if (f->valid_bits == INVALID_BITS) goto error; // behavior according to spec
+            step2_flag[0] = step2_flag[1] = 1;
+            for (j=2; j < g->values; ++j) {
+               int low, high, pred, highroom, lowroom, room, val;
+               low = g->neighbors[j][0];
+               high = g->neighbors[j][1];
+               //neighbors(g->Xlist, j, &low, &high);
+               pred = predict_point(g->Xlist[j], g->Xlist[low], g->Xlist[high], finalY[low], finalY[high]);
+               val = finalY[j];
+               highroom = range - pred;
+               lowroom = pred;
+               if (highroom < lowroom)
+                  room = highroom * 2;
+               else
+                  room = lowroom * 2;
+               if (val) {
+                  step2_flag[low] = step2_flag[high] = 1;
+                  step2_flag[j] = 1;
+                  if (val >= room)
+                     if (highroom > lowroom)
+                        finalY[j] = val - lowroom + pred;
+                     else
+                        finalY[j] = pred - val + highroom - 1;
+                  else
+                     if (val & 1)
+                        finalY[j] = pred - ((val+1)>>1);
+                     else
+                        finalY[j] = pred + (val>>1);
+               } else {
+                  step2_flag[j] = 0;
+                  finalY[j] = pred;
+               }
+            }
+
+#ifdef STB_VORBIS_NO_DEFER_FLOOR
+            do_floor(f, map, i, n, f->floor_buffers[i], finalY, step2_flag);
+#else
+            // defer final floor computation until _after_ residue
+            for (j=0; j < g->values; ++j) {
+               if (!step2_flag[j])
+                  finalY[j] = -1;
+            }
+#endif
+         } else {
+           error:
+            zero_channel[i] = TRUE;
+         }
+         // So we just defer everything else to later
+
+         // at this point we've decoded the floor into buffer
+      }
+   }
+   stb_prof(0);
+   // at this point we've decoded all floors
+
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+
+   // re-enable coupled channels if necessary
+   memcpy(really_zero_channel, zero_channel, sizeof(really_zero_channel[0]) * f->channels);
+   for (i=0; i < map->coupling_steps; ++i)
+      if (!zero_channel[map->chan[i].magnitude] || !zero_channel[map->chan[i].angle]) {
+         zero_channel[map->chan[i].magnitude] = zero_channel[map->chan[i].angle] = FALSE;
+      }
+
+// RESIDUE DECODE
+   for (i=0; i < map->submaps; ++i) {
+      float *residue_buffers[STB_VORBIS_MAX_CHANNELS];
+      int r,t;
+      uint8 do_not_decode[256];
+      int ch = 0;
+      for (j=0; j < f->channels; ++j) {
+         if (map->chan[j].mux == i) {
+            if (zero_channel[j]) {
+               do_not_decode[ch] = TRUE;
+               residue_buffers[ch] = NULL;
+            } else {
+               do_not_decode[ch] = FALSE;
+               residue_buffers[ch] = f->channel_buffers[j];
+            }
+            ++ch;
+         }
+      }
+      r = map->submap_residue[i];
+      t = f->residue_types[r];
+      decode_residue(f, residue_buffers, ch, n2, r, do_not_decode);
+   }
+
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+
+// INVERSE COUPLING
+   stb_prof(14);
+   for (i = map->coupling_steps-1; i >= 0; --i) {
+      int n2 = n >> 1;
+      float *m = f->channel_buffers[map->chan[i].magnitude];
+      float *a = f->channel_buffers[map->chan[i].angle    ];
+      for (j=0; j < n2; ++j) {
+         float a2,m2;
+         if (m[j] > 0)
+            if (a[j] > 0)
+               m2 = m[j], a2 = m[j] - a[j];
+            else
+               a2 = m[j], m2 = m[j] + a[j];
+         else
+            if (a[j] > 0)
+               m2 = m[j], a2 = m[j] + a[j];
+            else
+               a2 = m[j], m2 = m[j] - a[j];
+         m[j] = m2;
+         a[j] = a2;
+      }
+   }
+
+   // finish decoding the floors
+#ifndef STB_VORBIS_NO_DEFER_FLOOR
+   stb_prof(15);
+   for (i=0; i < f->channels; ++i) {
+      if (really_zero_channel[i]) {
+         memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2);
+      } else {
+         do_floor(f, map, i, n, f->channel_buffers[i], f->finalY[i], NULL);
+      }
+   }
+#else
+   for (i=0; i < f->channels; ++i) {
+      if (really_zero_channel[i]) {
+         memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2);
+      } else {
+         for (j=0; j < n2; ++j)
+            f->channel_buffers[i][j] *= f->floor_buffers[i][j];
+      }
+   }
+#endif
+
+// INVERSE MDCT
+   stb_prof(16);
+   for (i=0; i < f->channels; ++i)
+      inverse_mdct(f->channel_buffers[i], n, f, m->blockflag);
+   stb_prof(0);
+
+   // this shouldn't be necessary, unless we exited on an error
+   // and want to flush to get to the next packet
+   flush_packet(f);
+
+   if (f->first_decode) {
+      // assume we start so first non-discarded sample is sample 0
+      // this isn't to spec, but spec would require us to read ahead
+      // and decode the size of all current frames--could be done,
+      // but presumably it's not a commonly used feature
+      f->current_loc = -n2; // start of first frame is positioned for discard
+      // we might have to discard samples "from" the next frame too,
+      // if we're lapping a large block then a small at the start?
+      f->discard_samples_deferred = n - right_end;
+      f->current_loc_valid = TRUE;
+      f->first_decode = FALSE;
+   } else if (f->discard_samples_deferred) {
+      left_start += f->discard_samples_deferred;
+      *p_left = left_start;
+      f->discard_samples_deferred = 0;
+   } else if (f->previous_length == 0 && f->current_loc_valid) {
+      // we're recovering from a seek... that means we're going to discard
+      // the samples from this packet even though we know our position from
+      // the last page header, so we need to update the position based on
+      // the discarded samples here
+      // but wait, the code below is going to add this in itself even
+      // on a discard, so we don't need to do it here...
+   }
+
+   // check if we have ogg information about the sample # for this packet
+   if (f->last_seg_which == f->end_seg_with_known_loc) {
+      // if we have a valid current loc, and this is final:
+      if (f->current_loc_valid && (f->page_flag & PAGEFLAG_last_page)) {
+         uint32 current_end = f->known_loc_for_packet - (n-right_end);
+         // then let's infer the size of the (probably) short final frame
+         if (current_end < f->current_loc + right_end) {
+            if (current_end < f->current_loc) {
+               // negative truncation, that's impossible!
+               *len = 0;
+            } else {
+               *len = current_end - f->current_loc;
+            }
+            *len += left_start;
+            f->current_loc += *len;
+            return TRUE;
+         }
+      }
+      // otherwise, just set our sample loc
+      // guess that the ogg granule pos refers to the _middle_ of the
+      // last frame?
+      // set f->current_loc to the position of left_start
+      f->current_loc = f->known_loc_for_packet - (n2-left_start);
+      f->current_loc_valid = TRUE;
+   }
+   if (f->current_loc_valid)
+      f->current_loc += (right_start - left_start);
+
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+   *len = right_end;  // ignore samples after the window goes to 0
+   return TRUE;
+}
+
+static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right)
+{
+   int mode, left_end, right_end;
+   if (!vorbis_decode_initial(f, p_left, &left_end, p_right, &right_end, &mode)) return 0;
+   return vorbis_decode_packet_rest(f, len, f->mode_config + mode, *p_left, left_end, *p_right, right_end, p_left);
+}
+
+static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right)
+{
+   int prev,i,j;
+   // we use right&left (the start of the right- and left-window sin()-regions)
+   // to determine how much to return, rather than inferring from the rules
+   // (same result, clearer code); 'left' indicates where our sin() window
+   // starts, therefore where the previous window's right edge starts, and
+   // therefore where to start mixing from the previous buffer. 'right'
+   // indicates where our sin() ending-window starts, therefore that's where
+   // we start saving, and where our returned-data ends.
+
+   // mixin from previous window
+   if (f->previous_length) {
+      int i,j, n = f->previous_length;
+      float *w = get_window(f, n);
+      for (i=0; i < f->channels; ++i) {
+         for (j=0; j < n; ++j)
+            f->channel_buffers[i][left+j] =
+               f->channel_buffers[i][left+j]*w[    j] +
+               f->previous_window[i][     j]*w[n-1-j];
+      }
+   }
+
+   prev = f->previous_length;
+
+   // last half of this data becomes previous window
+   f->previous_length = len - right;
+
+   // @OPTIMIZE: could avoid this copy by double-buffering the
+   // output (flipping previous_window with channel_buffers), but
+   // then previous_window would have to be 2x as large, and
+   // channel_buffers couldn't be temp mem (although they're NOT
+   // currently temp mem, they could be (unless we want to level
+   // performance by spreading out the computation))
+   for (i=0; i < f->channels; ++i)
+      for (j=0; right+j < len; ++j)
+         f->previous_window[i][j] = f->channel_buffers[i][right+j];
+
+   if (!prev)
+      // there was no previous packet, so this data isn't valid...
+      // this isn't entirely true, only the would-have-overlapped data
+      // isn't valid, but this seems to be what the spec requires
+      return 0;
+
+   // truncate a short frame
+   if (len < right) right = len;
+
+   f->samples_output += right-left;
+
+   return right - left;
+}
+
+static void vorbis_pump_first_frame(stb_vorbis *f)
+{
+   int len, right, left;
+   if (vorbis_decode_packet(f, &len, &left, &right))
+      vorbis_finish_frame(f, len, left, right);
+}
+
+#ifndef STB_VORBIS_NO_PUSHDATA_API
+static int is_whole_packet_present(stb_vorbis *f, int end_page)
+{
+   // make sure that we have the packet available before continuing...
+   // this requires a full ogg parse, but we know we can fetch from f->stream
+
+   // instead of coding this out explicitly, we could save the current read state,
+   // read the next packet with get8() until end-of-packet, check f->eof, then
+   // reset the state? but that would be slower, esp. since we'd have over 256 bytes
+   // of state to restore (primarily the page segment table)
+
+   int s = f->next_seg, first = TRUE;
+   uint8 *p = f->stream;
+
+   if (s != -1) { // if we're not starting the packet with a 'continue on next page' flag
+      for (; s < f->segment_count; ++s) {
+         p += f->segments[s];
+         if (f->segments[s] < 255)               // stop at first short segment
+            break;
+      }
+      // either this continues, or it ends it...
+      if (end_page)
+         if (s < f->segment_count-1)             return error(f, VORBIS_invalid_stream);
+      if (s == f->segment_count)
+         s = -1; // set 'crosses page' flag
+      if (p > f->stream_end)                     return error(f, VORBIS_need_more_data);
+      first = FALSE;
+   }
+   for (; s == -1;) {
+      uint8 *q; 
+      int n;
+
+      // check that we have the page header ready
+      if (p + 26 >= f->stream_end)               return error(f, VORBIS_need_more_data);
+      // validate the page
+      if (memcmp(p, ogg_page_header, 4))         return error(f, VORBIS_invalid_stream);
+      if (p[4] != 0)                             return error(f, VORBIS_invalid_stream);
+      if (first) { // the first segment must NOT have 'continued_packet', later ones MUST
+         if (f->previous_length)
+            if ((p[5] & PAGEFLAG_continued_packet))  return error(f, VORBIS_invalid_stream);
+         // if no previous length, we're resynching, so we can come in on a continued-packet,
+         // which we'll just drop
+      } else {
+         if (!(p[5] & PAGEFLAG_continued_packet)) return error(f, VORBIS_invalid_stream);
+      }
+      n = p[26]; // segment counts
+      q = p+27;  // q points to segment table
+      p = q + n; // advance past header
+      // make sure we've read the segment table
+      if (p > f->stream_end)                     return error(f, VORBIS_need_more_data);
+      for (s=0; s < n; ++s) {
+         p += q[s];
+         if (q[s] < 255)
+            break;
+      }
+      if (end_page)
+         if (s < n-1)                            return error(f, VORBIS_invalid_stream);
+      if (s == f->segment_count)
+         s = -1; // set 'crosses page' flag
+      if (p > f->stream_end)                     return error(f, VORBIS_need_more_data);
+      first = FALSE;
+   }
+   return TRUE;
+}
+#endif // !STB_VORBIS_NO_PUSHDATA_API
+
+static int start_decoder(vorb *f)
+{
+   uint8 header[6], x,y;
+   int len,i,j,k, max_submaps = 0;
+   int longest_floorlist=0;
+
+   // first page, first packet
+
+   if (!start_page(f))                              return FALSE;
+   // validate page flag
+   if (!(f->page_flag & PAGEFLAG_first_page))       return error(f, VORBIS_invalid_first_page);
+   if (f->page_flag & PAGEFLAG_last_page)           return error(f, VORBIS_invalid_first_page);
+   if (f->page_flag & PAGEFLAG_continued_packet)    return error(f, VORBIS_invalid_first_page);
+   // check for expected packet length
+   if (f->segment_count != 1)                       return error(f, VORBIS_invalid_first_page);
+   if (f->segments[0] != 30)                        return error(f, VORBIS_invalid_first_page);
+   // read packet
+   // check packet header
+   if (get8(f) != VORBIS_packet_id)                 return error(f, VORBIS_invalid_first_page);
+   if (!getn(f, header, 6))                         return error(f, VORBIS_unexpected_eof);
+   if (!vorbis_validate(header))                    return error(f, VORBIS_invalid_first_page);
+   // vorbis_version
+   if (get32(f) != 0)                               return error(f, VORBIS_invalid_first_page);
+   f->channels = get8(f); if (!f->channels)         return error(f, VORBIS_invalid_first_page);
+   if (f->channels > STB_VORBIS_MAX_CHANNELS)       return error(f, VORBIS_too_many_channels);
+   f->sample_rate = get32(f); if (!f->sample_rate)  return error(f, VORBIS_invalid_first_page);
+   get32(f); // bitrate_maximum
+   get32(f); // bitrate_nominal
+   get32(f); // bitrate_minimum
+   x = get8(f);
+   { int log0,log1;
+   log0 = x & 15;
+   log1 = x >> 4;
+   f->blocksize_0 = 1 << log0;
+   f->blocksize_1 = 1 << log1;
+   if (log0 < 6 || log0 > 13)                       return error(f, VORBIS_invalid_setup);
+   if (log1 < 6 || log1 > 13)                       return error(f, VORBIS_invalid_setup);
+   if (log0 > log1)                                 return error(f, VORBIS_invalid_setup);
+   }
+
+   // framing_flag
+   x = get8(f);
+   if (!(x & 1))                                    return error(f, VORBIS_invalid_first_page);
+
+   // second packet!
+   if (!start_page(f))                              return FALSE;
+
+   if (!start_packet(f))                            return FALSE;
+   do {
+      len = next_segment(f);
+      skip(f, len);
+      f->bytes_in_seg = 0;
+   } while (len);
+
+   // third packet!
+   if (!start_packet(f))                            return FALSE;
+
+   #ifndef STB_VORBIS_NO_PUSHDATA_API
+   if (IS_PUSH_MODE(f)) {
+      if (!is_whole_packet_present(f, TRUE)) {
+         // convert error in ogg header to write type
+         if (f->error == VORBIS_invalid_stream)
+            f->error = VORBIS_invalid_setup;
+         return FALSE;
+      }
+   }
+   #endif
+
+   crc32_init(); // always init it, to avoid multithread race conditions
+
+   if (get8_packet(f) != VORBIS_packet_setup)       return error(f, VORBIS_invalid_setup);
+   for (i=0; i < 6; ++i) header[i] = get8_packet(f);
+   if (!vorbis_validate(header))                    return error(f, VORBIS_invalid_setup);
+
+   // codebooks
+
+   f->codebook_count = get_bits(f,8) + 1;
+   f->codebooks = (Codebook *) setup_malloc(f, sizeof(*f->codebooks) * f->codebook_count);
+   if (f->codebooks == NULL)                        return error(f, VORBIS_outofmem);
+   memset(f->codebooks, 0, sizeof(*f->codebooks) * f->codebook_count);
+   for (i=0; i < f->codebook_count; ++i) {
+      uint32 *values;
+      int ordered, sorted_count;
+      int total=0;
+      uint8 *lengths;
+      Codebook *c = f->codebooks+i;
+      x = get_bits(f, 8); if (x != 0x42)            return error(f, VORBIS_invalid_setup);
+      x = get_bits(f, 8); if (x != 0x43)            return error(f, VORBIS_invalid_setup);
+      x = get_bits(f, 8); if (x != 0x56)            return error(f, VORBIS_invalid_setup);
+      x = get_bits(f, 8);
+      c->dimensions = (get_bits(f, 8)<<8) + x;
+      x = get_bits(f, 8);
+      y = get_bits(f, 8);
+      c->entries = (get_bits(f, 8)<<16) + (y<<8) + x;
+      ordered = get_bits(f,1);
+      c->sparse = ordered ? 0 : get_bits(f,1);
+
+      if (c->sparse)
+         lengths = (uint8 *) setup_temp_malloc(f, c->entries);
+      else
+         lengths = c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries);
+
+      if (!lengths) return error(f, VORBIS_outofmem);
+
+      if (ordered) {
+         int current_entry = 0;
+         int current_length = get_bits(f,5) + 1;
+         while (current_entry < c->entries) {
+            int limit = c->entries - current_entry;
+            int n = get_bits(f, ilog(limit));
+            if (current_entry + n > (int) c->entries) { return error(f, VORBIS_invalid_setup); }
+            memset(lengths + current_entry, current_length, n);
+            current_entry += n;
+            ++current_length;
+         }
+      } else {
+         for (j=0; j < c->entries; ++j) {
+            int present = c->sparse ? get_bits(f,1) : 1;
+            if (present) {
+               lengths[j] = get_bits(f, 5) + 1;
+               ++total;
+            } else {
+               lengths[j] = NO_CODE;
+            }
+         }
+      }
+
+      if (c->sparse && total >= c->entries >> 2) {
+         // convert sparse items to non-sparse!
+         if (c->entries > (int) f->setup_temp_memory_required)
+            f->setup_temp_memory_required = c->entries;
+
+         c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries);
+         memcpy(c->codeword_lengths, lengths, c->entries);
+         setup_temp_free(f, lengths, c->entries); // note this is only safe if there have been no intervening temp mallocs!
+         lengths = c->codeword_lengths;
+         c->sparse = 0;
+      }
+
+      // compute the size of the sorted tables
+      if (c->sparse) {
+         sorted_count = total;
+         //assert(total != 0);
+      } else {
+         sorted_count = 0;
+         #ifndef STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH
+         for (j=0; j < c->entries; ++j)
+            if (lengths[j] > STB_VORBIS_FAST_HUFFMAN_LENGTH && lengths[j] != NO_CODE)
+               ++sorted_count;
+         #endif
+      }
+
+      c->sorted_entries = sorted_count;
+      values = NULL;
+
+      if (!c->sparse) {
+         c->codewords = (uint32 *) setup_malloc(f, sizeof(c->codewords[0]) * c->entries);
+         if (!c->codewords)                  return error(f, VORBIS_outofmem);
+      } else {
+         unsigned int size;
+         if (c->sorted_entries) {
+            c->codeword_lengths = (uint8 *) setup_malloc(f, c->sorted_entries);
+            if (!c->codeword_lengths)           return error(f, VORBIS_outofmem);
+            c->codewords = (uint32 *) setup_temp_malloc(f, sizeof(*c->codewords) * c->sorted_entries);
+            if (!c->codewords)                  return error(f, VORBIS_outofmem);
+            values = (uint32 *) setup_temp_malloc(f, sizeof(*values) * c->sorted_entries);
+            if (!values)                        return error(f, VORBIS_outofmem);
+         }
+         size = c->entries + (sizeof(*c->codewords) + sizeof(*values)) * c->sorted_entries;
+         if (size > f->setup_temp_memory_required)
+            f->setup_temp_memory_required = size;
+      }
+
+      if (!compute_codewords(c, lengths, c->entries, values)) {
+         if (c->sparse) setup_temp_free(f, values, 0);
+         return error(f, VORBIS_invalid_setup);
+      }
+
+      if (c->sorted_entries) {
+         // allocate an extra slot for sentinels
+         c->sorted_codewords = (uint32 *) setup_malloc(f, sizeof(*c->sorted_codewords) * (c->sorted_entries+1));
+         // allocate an extra slot at the front so that c->sorted_values[-1] is defined
+         // so that we can catch that case without an extra if
+         c->sorted_values    = ( int   *) setup_malloc(f, sizeof(*c->sorted_values   ) * (c->sorted_entries+1));
+         if (c->sorted_values) { ++c->sorted_values; c->sorted_values[-1] = -1; }
+         compute_sorted_huffman(c, lengths, values);
+      }
+
+      if (c->sparse) {
+         setup_temp_free(f, values, sizeof(*values)*c->sorted_entries);
+         setup_temp_free(f, c->codewords, sizeof(*c->codewords)*c->sorted_entries);
+         setup_temp_free(f, lengths, c->entries);
+         c->codewords = NULL;
+      }
+
+      compute_accelerated_huffman(c);
+
+      c->lookup_type = get_bits(f, 4);
+      if (c->lookup_type > 2) return error(f, VORBIS_invalid_setup);
+      if (c->lookup_type > 0) {
+         uint16 *mults;
+         c->minimum_value = float32_unpack(get_bits(f, 32));
+         c->delta_value = float32_unpack(get_bits(f, 32));
+         c->value_bits = get_bits(f, 4)+1;
+         c->sequence_p = get_bits(f,1);
+         if (c->lookup_type == 1) {
+            c->lookup_values = lookup1_values(c->entries, c->dimensions);
+         } else {
+            c->lookup_values = c->entries * c->dimensions;
+         }
+         mults = (uint16 *) setup_temp_malloc(f, sizeof(mults[0]) * c->lookup_values);
+         if (mults == NULL) return error(f, VORBIS_outofmem);
+         for (j=0; j < (int) c->lookup_values; ++j) {
+            int q = get_bits(f, c->value_bits);
+            if (q == EOP) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_invalid_setup); }
+            mults[j] = q;
+         }
+
+#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
+         if (c->lookup_type == 1) {
+            int len, sparse = c->sparse;
+            // pre-expand the lookup1-style multiplicands, to avoid a divide in the inner loop
+            if (sparse) {
+               if (c->sorted_entries == 0) goto skip;
+               c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->sorted_entries * c->dimensions);
+            } else
+               c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->entries        * c->dimensions);
+            if (c->multiplicands == NULL) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); }
+            len = sparse ? c->sorted_entries : c->entries;
+            for (j=0; j < len; ++j) {
+               int z = sparse ? c->sorted_values[j] : j, div=1;
+               for (k=0; k < c->dimensions; ++k) {
+                  int off = (z / div) % c->lookup_values;
+                  c->multiplicands[j*c->dimensions + k] =
+                         #ifndef STB_VORBIS_CODEBOOK_FLOATS
+                            mults[off];
+                         #else
+                            mults[off]*c->delta_value + c->minimum_value;
+                            // in this case (and this case only) we could pre-expand c->sequence_p,
+                            // and throw away the decode logic for it; have to ALSO do
+                            // it in the case below, but it can only be done if
+                            //    STB_VORBIS_CODEBOOK_FLOATS
+                            //   !STB_VORBIS_DIVIDES_IN_CODEBOOK
+                         #endif
+                  div *= c->lookup_values;
+               }
+            }
+            setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values);
+            c->lookup_type = 2;
+         }
+         else
+#endif
+         {
+            c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->lookup_values);
+            #ifndef STB_VORBIS_CODEBOOK_FLOATS
+            memcpy(c->multiplicands, mults, sizeof(c->multiplicands[0]) * c->lookup_values);
+            #else
+            for (j=0; j < (int) c->lookup_values; ++j)
+               c->multiplicands[j] = mults[j] * c->delta_value + c->minimum_value;
+            setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values);
+            #endif
+         }
+        skip:;
+
+         #ifdef STB_VORBIS_CODEBOOK_FLOATS
+         if (c->lookup_type == 2 && c->sequence_p) {
+            for (j=1; j < (int) c->lookup_values; ++j)
+               c->multiplicands[j] = c->multiplicands[j-1];
+            c->sequence_p = 0;
+         }
+         #endif
+      }
+   }
+
+   // time domain transfers (notused)
+
+   x = get_bits(f, 6) + 1;
+   for (i=0; i < x; ++i) {
+      uint32 z = get_bits(f, 16);
+      if (z != 0) return error(f, VORBIS_invalid_setup);
+   }
+
+   // Floors
+   f->floor_count = get_bits(f, 6)+1;
+   f->floor_config = (Floor *)  setup_malloc(f, f->floor_count * sizeof(*f->floor_config));
+   for (i=0; i < f->floor_count; ++i) {
+      f->floor_types[i] = get_bits(f, 16);
+      if (f->floor_types[i] > 1) return error(f, VORBIS_invalid_setup);
+      if (f->floor_types[i] == 0) {
+         Floor0 *g = &f->floor_config[i].floor0;
+         g->order = get_bits(f,8);
+         g->rate = get_bits(f,16);
+         g->bark_map_size = get_bits(f,16);
+         g->amplitude_bits = get_bits(f,6);
+         g->amplitude_offset = get_bits(f,8);
+         g->number_of_books = get_bits(f,4) + 1;
+         for (j=0; j < g->number_of_books; ++j)
+            g->book_list[j] = get_bits(f,8);
+         return error(f, VORBIS_feature_not_supported);
+      } else {
+         Point p[31*8+2];
+         Floor1 *g = &f->floor_config[i].floor1;
+         int max_class = -1; 
+         g->partitions = get_bits(f, 5);
+         for (j=0; j < g->partitions; ++j) {
+            g->partition_class_list[j] = get_bits(f, 4);
+            if (g->partition_class_list[j] > max_class)
+               max_class = g->partition_class_list[j];
+         }
+         for (j=0; j <= max_class; ++j) {
+            g->class_dimensions[j] = get_bits(f, 3)+1;
+            g->class_subclasses[j] = get_bits(f, 2);
+            if (g->class_subclasses[j]) {
+               g->class_masterbooks[j] = get_bits(f, 8);
+               if (g->class_masterbooks[j] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
+            }
+            for (k=0; k < 1 << g->class_subclasses[j]; ++k) {
+               g->subclass_books[j][k] = get_bits(f,8)-1;
+               if (g->subclass_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
+            }
+         }
+         g->floor1_multiplier = get_bits(f,2)+1;
+         g->rangebits = get_bits(f,4);
+         g->Xlist[0] = 0;
+         g->Xlist[1] = 1 << g->rangebits;
+         g->values = 2;
+         for (j=0; j < g->partitions; ++j) {
+            int c = g->partition_class_list[j];
+            for (k=0; k < g->class_dimensions[c]; ++k) {
+               g->Xlist[g->values] = get_bits(f, g->rangebits);
+               ++g->values;
+            }
+         }
+         // precompute the sorting
+         for (j=0; j < g->values; ++j) {
+            p[j].x = g->Xlist[j];
+            p[j].y = j;
+         }
+         qsort(p, g->values, sizeof(p[0]), point_compare);
+         for (j=0; j < g->values; ++j)
+            g->sorted_order[j] = (uint8) p[j].y;
+         // precompute the neighbors
+         for (j=2; j < g->values; ++j) {
+            int low,hi;
+            neighbors(g->Xlist, j, &low,&hi);
+            g->neighbors[j][0] = low;
+            g->neighbors[j][1] = hi;
+         }
+
+         if (g->values > longest_floorlist)
+            longest_floorlist = g->values;
+      }
+   }
+
+   // Residue
+   f->residue_count = get_bits(f, 6)+1;
+   f->residue_config = (Residue *) setup_malloc(f, f->residue_count * sizeof(*f->residue_config));
+   for (i=0; i < f->residue_count; ++i) {
+      uint8 residue_cascade[64];
+      Residue *r = f->residue_config+i;
+      f->residue_types[i] = get_bits(f, 16);
+      if (f->residue_types[i] > 2) return error(f, VORBIS_invalid_setup);
+      r->begin = get_bits(f, 24);
+      r->end = get_bits(f, 24);
+      r->part_size = get_bits(f,24)+1;
+      r->classifications = get_bits(f,6)+1;
+      r->classbook = get_bits(f,8);
+      for (j=0; j < r->classifications; ++j) {
+         uint8 high_bits=0;
+         uint8 low_bits=get_bits(f,3);
+         if (get_bits(f,1))
+            high_bits = get_bits(f,5);
+         residue_cascade[j] = high_bits*8 + low_bits;
+      }
+      r->residue_books = (short (*)[8]) setup_malloc(f, sizeof(r->residue_books[0]) * r->classifications);
+      for (j=0; j < r->classifications; ++j) {
+         for (k=0; k < 8; ++k) {
+            if (residue_cascade[j] & (1 << k)) {
+               r->residue_books[j][k] = get_bits(f, 8);
+               if (r->residue_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
+            } else {
+               r->residue_books[j][k] = -1;
+            }
+         }
+      }
+      // precompute the classifications[] array to avoid inner-loop mod/divide
+      // call it 'classdata' since we already have r->classifications
+      r->classdata = (uint8 **) setup_malloc(f, sizeof(*r->classdata) * f->codebooks[r->classbook].entries);
+      if (!r->classdata) return error(f, VORBIS_outofmem);
+      memset(r->classdata, 0, sizeof(*r->classdata) * f->codebooks[r->classbook].entries);
+      for (j=0; j < f->codebooks[r->classbook].entries; ++j) {
+         int classwords = f->codebooks[r->classbook].dimensions;
+         int temp = j;
+         r->classdata[j] = (uint8 *) setup_malloc(f, sizeof(r->classdata[j][0]) * classwords);
+         for (k=classwords-1; k >= 0; --k) {
+            r->classdata[j][k] = temp % r->classifications;
+            temp /= r->classifications;
+         }
+      }
+   }
+
+   f->mapping_count = get_bits(f,6)+1;
+   f->mapping = (Mapping *) setup_malloc(f, f->mapping_count * sizeof(*f->mapping));
+   for (i=0; i < f->mapping_count; ++i) {
+      Mapping *m = f->mapping + i;      
+      int mapping_type = get_bits(f,16);
+      if (mapping_type != 0) return error(f, VORBIS_invalid_setup);
+      m->chan = (MappingChannel *) setup_malloc(f, f->channels * sizeof(*m->chan));
+      if (get_bits(f,1))
+         m->submaps = get_bits(f,4);
+      else
+         m->submaps = 1;
+      if (m->submaps > max_submaps)
+         max_submaps = m->submaps;
+      if (get_bits(f,1)) {
+         m->coupling_steps = get_bits(f,8)+1;
+         for (k=0; k < m->coupling_steps; ++k) {
+            m->chan[k].magnitude = get_bits(f, ilog(f->channels)-1);
+            m->chan[k].angle = get_bits(f, ilog(f->channels)-1);
+            if (m->chan[k].magnitude >= f->channels)        return error(f, VORBIS_invalid_setup);
+            if (m->chan[k].angle     >= f->channels)        return error(f, VORBIS_invalid_setup);
+            if (m->chan[k].magnitude == m->chan[k].angle)   return error(f, VORBIS_invalid_setup);
+         }
+      } else
+         m->coupling_steps = 0;
+
+      // reserved field
+      if (get_bits(f,2)) return error(f, VORBIS_invalid_setup);
+      if (m->submaps > 1) {
+         for (j=0; j < f->channels; ++j) {
+            m->chan[j].mux = get_bits(f, 4);
+            if (m->chan[j].mux >= m->submaps)                return error(f, VORBIS_invalid_setup);
+         }
+      } else
+         // @SPECIFICATION: this case is missing from the spec
+         for (j=0; j < f->channels; ++j)
+            m->chan[j].mux = 0;
+
+      for (j=0; j < m->submaps; ++j) {
+         get_bits(f,8); // discard
+         m->submap_floor[j] = get_bits(f,8);
+         m->submap_residue[j] = get_bits(f,8);
+         if (m->submap_floor[j] >= f->floor_count)      return error(f, VORBIS_invalid_setup);
+         if (m->submap_residue[j] >= f->residue_count)  return error(f, VORBIS_invalid_setup);
+      }
+   }
+
+   // Modes
+   f->mode_count = get_bits(f, 6)+1;
+   for (i=0; i < f->mode_count; ++i) {
+      Mode *m = f->mode_config+i;
+      m->blockflag = get_bits(f,1);
+      m->windowtype = get_bits(f,16);
+      m->transformtype = get_bits(f,16);
+      m->mapping = get_bits(f,8);
+      if (m->windowtype != 0)                 return error(f, VORBIS_invalid_setup);
+      if (m->transformtype != 0)              return error(f, VORBIS_invalid_setup);
+      if (m->mapping >= f->mapping_count)     return error(f, VORBIS_invalid_setup);
+   }
+
+   flush_packet(f);
+
+   f->previous_length = 0;
+
+   for (i=0; i < f->channels; ++i) {
+      f->channel_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1);
+      f->previous_window[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2);
+      f->finalY[i]          = (int16 *) setup_malloc(f, sizeof(int16) * longest_floorlist);
+      #ifdef STB_VORBIS_NO_DEFER_FLOOR
+      f->floor_buffers[i]   = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2);
+      #endif
+   }
+
+   if (!init_blocksize(f, 0, f->blocksize_0)) return FALSE;
+   if (!init_blocksize(f, 1, f->blocksize_1)) return FALSE;
+   f->blocksize[0] = f->blocksize_0;
+   f->blocksize[1] = f->blocksize_1;
+
+#ifdef STB_VORBIS_DIVIDE_TABLE
+   if (integer_divide_table[1][1]==0)
+      for (i=0; i < DIVTAB_NUMER; ++i)
+         for (j=1; j < DIVTAB_DENOM; ++j)
+            integer_divide_table[i][j] = i / j;
+#endif
+
+   // compute how much temporary memory is needed
+
+   // 1.
+   {
+      uint32 imdct_mem = (f->blocksize_1 * sizeof(float) >> 1);
+      uint32 classify_mem;
+      int i,max_part_read=0;
+      for (i=0; i < f->residue_count; ++i) {
+         Residue *r = f->residue_config + i;
+         int n_read = r->end - r->begin;
+         int part_read = n_read / r->part_size;
+         if (part_read > max_part_read)
+            max_part_read = part_read;
+      }
+      #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+      classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(uint8 *));
+      #else
+      classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(int *));
+      #endif
+
+      f->temp_memory_required = classify_mem;
+      if (imdct_mem > f->temp_memory_required)
+         f->temp_memory_required = imdct_mem;
+   }
+
+   f->first_decode = TRUE;
+
+   if (f->alloc.alloc_buffer) {
+      assert(f->temp_offset == f->alloc.alloc_buffer_length_in_bytes);
+      // check if there's enough temp memory so we don't error later
+      if (f->setup_offset + sizeof(*f) + f->temp_memory_required > (unsigned) f->temp_offset)
+         return error(f, VORBIS_outofmem);
+   }
+
+   f->first_audio_page_offset = stb_vorbis_get_file_offset(f);
+
+   return TRUE;
+}
+
+static void vorbis_deinit(stb_vorbis *p)
+{
+   int i,j;
+   for (i=0; i < p->residue_count; ++i) {
+      Residue *r = p->residue_config+i;
+      if (r->classdata) {
+         for (j=0; j < p->codebooks[r->classbook].entries; ++j)
+            setup_free(p, r->classdata[j]);
+         setup_free(p, r->classdata);
+      }
+      setup_free(p, r->residue_books);
+   }
+
+   if (p->codebooks) {
+      for (i=0; i < p->codebook_count; ++i) {
+         Codebook *c = p->codebooks + i;
+         setup_free(p, c->codeword_lengths);
+         setup_free(p, c->multiplicands);
+         setup_free(p, c->codewords);
+         setup_free(p, c->sorted_codewords);
+         // c->sorted_values[-1] is the first entry in the array
+         setup_free(p, c->sorted_values ? c->sorted_values-1 : NULL);
+      }
+      setup_free(p, p->codebooks);
+   }
+   setup_free(p, p->floor_config);
+   setup_free(p, p->residue_config);
+   for (i=0; i < p->mapping_count; ++i)
+      setup_free(p, p->mapping[i].chan);
+   setup_free(p, p->mapping);
+   for (i=0; i < p->channels; ++i) {
+      setup_free(p, p->channel_buffers[i]);
+      setup_free(p, p->previous_window[i]);
+      #ifdef STB_VORBIS_NO_DEFER_FLOOR
+      setup_free(p, p->floor_buffers[i]);
+      #endif
+      setup_free(p, p->finalY[i]);
+   }
+   for (i=0; i < 2; ++i) {
+      setup_free(p, p->A[i]);
+      setup_free(p, p->B[i]);
+      setup_free(p, p->C[i]);
+      setup_free(p, p->window[i]);
+   }
+   #ifndef STB_VORBIS_NO_STDIO
+   if (p->close_on_free) fclose(p->f);
+   #endif
+}
+
+void stb_vorbis_close(stb_vorbis *p)
+{
+   if (p == NULL) return;
+   vorbis_deinit(p);
+   setup_free(p,p);
+}
+
+static void vorbis_init(stb_vorbis *p, stb_vorbis_alloc *z)
+{
+   memset(p, 0, sizeof(*p)); // NULL out all malloc'd pointers to start
+   if (z) {
+      p->alloc = *z;
+      p->alloc.alloc_buffer_length_in_bytes = (p->alloc.alloc_buffer_length_in_bytes+3) & ~3;
+      p->temp_offset = p->alloc.alloc_buffer_length_in_bytes;
+   }
+   p->eof = 0;
+   p->error = VORBIS__no_error;
+   p->stream = NULL;
+   p->codebooks = NULL;
+   p->page_crc_tests = -1;
+   #ifndef STB_VORBIS_NO_STDIO
+   p->close_on_free = FALSE;
+   p->f = NULL;
+   #endif
+}
+
+int stb_vorbis_get_sample_offset(stb_vorbis *f)
+{
+   if (f->current_loc_valid)
+      return f->current_loc;
+   else
+      return -1;
+}
+
+stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f)
+{
+   stb_vorbis_info d;
+   d.channels = f->channels;
+   d.sample_rate = f->sample_rate;
+   d.setup_memory_required = f->setup_memory_required;
+   d.setup_temp_memory_required = f->setup_temp_memory_required;
+   d.temp_memory_required = f->temp_memory_required;
+   d.max_frame_size = f->blocksize_1 >> 1;
+   return d;
+}
+
+int stb_vorbis_get_error(stb_vorbis *f)
+{
+   int e = f->error;
+   f->error = VORBIS__no_error;
+   return e;
+}
+
+static stb_vorbis * vorbis_alloc(stb_vorbis *f)
+{
+   stb_vorbis *p = (stb_vorbis *) setup_malloc(f, sizeof(*p));
+   return p;
+}
+
+#ifndef STB_VORBIS_NO_PUSHDATA_API
+
+void stb_vorbis_flush_pushdata(stb_vorbis *f)
+{
+   f->previous_length = 0;
+   f->page_crc_tests  = 0;
+   f->discard_samples_deferred = 0;
+   f->current_loc_valid = FALSE;
+   f->first_decode = FALSE;
+   f->samples_output = 0;
+   f->channel_buffer_start = 0;
+   f->channel_buffer_end = 0;
+}
+
+static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len)
+{
+   int i,n;
+   for (i=0; i < f->page_crc_tests; ++i)
+      f->scan[i].bytes_done = 0;
+
+   // if we have room for more scans, search for them first, because
+   // they may cause us to stop early if their header is incomplete
+   if (f->page_crc_tests < STB_VORBIS_PUSHDATA_CRC_COUNT) {
+      if (data_len < 4) return 0;
+      data_len -= 3; // need to look for 4-byte sequence, so don't miss
+                     // one that straddles a boundary
+      for (i=0; i < data_len; ++i) {
+         if (data[i] == 0x4f) {
+            if (0==memcmp(data+i, ogg_page_header, 4)) {
+               int j,len;
+               uint32 crc;
+               // make sure we have the whole page header
+               if (i+26 >= data_len || i+27+data[i+26] >= data_len) {
+                  // only read up to this page start, so hopefully we'll
+                  // have the whole page header start next time
+                  data_len = i;
+                  break;
+               }
+               // ok, we have it all; compute the length of the page
+               len = 27 + data[i+26];
+               for (j=0; j < data[i+26]; ++j)
+                  len += data[i+27+j];
+               // scan everything up to the embedded crc (which we must 0)
+               crc = 0;
+               for (j=0; j < 22; ++j)
+                  crc = crc32_update(crc, data[i+j]);
+               // now process 4 0-bytes
+               for (   ; j < 26; ++j)
+                  crc = crc32_update(crc, 0);
+               // len is the total number of bytes we need to scan
+               n = f->page_crc_tests++;
+               f->scan[n].bytes_left = len-j;
+               f->scan[n].crc_so_far = crc;
+               f->scan[n].goal_crc = data[i+22] + (data[i+23] << 8) + (data[i+24]<<16) + (data[i+25]<<24);
+               // if the last frame on a page is continued to the next, then
+               // we can't recover the sample_loc immediately
+               if (data[i+27+data[i+26]-1] == 255)
+                  f->scan[n].sample_loc = ~0;
+               else
+                  f->scan[n].sample_loc = data[i+6] + (data[i+7] << 8) + (data[i+ 8]<<16) + (data[i+ 9]<<24);
+               f->scan[n].bytes_done = i+j;
+               if (f->page_crc_tests == STB_VORBIS_PUSHDATA_CRC_COUNT)
+                  break;
+               // keep going if we still have room for more
+            }
+         }
+      }
+   }
+
+   for (i=0; i < f->page_crc_tests;) {
+      uint32 crc;
+      int j;
+      int n = f->scan[i].bytes_done;
+      int m = f->scan[i].bytes_left;
+      if (m > data_len - n) m = data_len - n;
+      // m is the bytes to scan in the current chunk
+      crc = f->scan[i].crc_so_far;
+      for (j=0; j < m; ++j)
+         crc = crc32_update(crc, data[n+j]);
+      f->scan[i].bytes_left -= m;
+      f->scan[i].crc_so_far = crc;
+      if (f->scan[i].bytes_left == 0) {
+         // does it match?
+         if (f->scan[i].crc_so_far == f->scan[i].goal_crc) {
+            // Houston, we have page
+            data_len = n+m; // consumption amount is wherever that scan ended
+            f->page_crc_tests = -1; // drop out of page scan mode
+            f->previous_length = 0; // decode-but-don't-output one frame
+            f->next_seg = -1;       // start a new page
+            f->current_loc = f->scan[i].sample_loc; // set the current sample location
+                                    // to the amount we'd have decoded had we decoded this page
+            f->current_loc_valid = f->current_loc != ~0;
+            return data_len;
+         }
+         // delete entry
+         f->scan[i] = f->scan[--f->page_crc_tests];
+      } else {
+         ++i;
+      }
+   }
+
+   return data_len;
+}
+
+// return value: number of bytes we used
+int stb_vorbis_decode_frame_pushdata(
+         stb_vorbis *f,                 // the file we're decoding
+         uint8 *data, int data_len,     // the memory available for decoding
+         int *channels,                 // place to write number of float * buffers
+         float ***output,               // place to write float ** array of float * buffers
+         int *samples                   // place to write number of output samples
+     )
+{
+   int i;
+   int len,right,left;
+
+   if (!IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+
+   if (f->page_crc_tests >= 0) {
+      *samples = 0;
+      return vorbis_search_for_page_pushdata(f, data, data_len);
+   }
+
+   f->stream     = data;
+   f->stream_end = data + data_len;
+   f->error      = VORBIS__no_error;
+
+   // check that we have the entire packet in memory
+   if (!is_whole_packet_present(f, FALSE)) {
+      *samples = 0;
+      return 0;
+   }
+
+   if (!vorbis_decode_packet(f, &len, &left, &right)) {
+      // save the actual error we encountered
+      enum STBVorbisError error = f->error;
+      if (error == VORBIS_bad_packet_type) {
+         // flush and resynch
+         f->error = VORBIS__no_error;
+         while (get8_packet(f) != EOP)
+            if (f->eof) break;
+         *samples = 0;
+         return f->stream - data;
+      }
+      if (error == VORBIS_continued_packet_flag_invalid) {
+         if (f->previous_length == 0) {
+            // we may be resynching, in which case it's ok to hit one
+            // of these; just discard the packet
+            f->error = VORBIS__no_error;
+            while (get8_packet(f) != EOP)
+               if (f->eof) break;
+            *samples = 0;
+            return f->stream - data;
+         }
+      }
+      // if we get an error while parsing, what to do?
+      // well, it DEFINITELY won't work to continue from where we are!
+      stb_vorbis_flush_pushdata(f);
+      // restore the error that actually made us bail
+      f->error = error;
+      *samples = 0;
+      return 1;
+   }
+
+   // success!
+   len = vorbis_finish_frame(f, len, left, right);
+   for (i=0; i < f->channels; ++i)
+      f->outputs[i] = f->channel_buffers[i] + left;
+
+   if (channels) *channels = f->channels;
+   *samples = len;
+   *output = f->outputs;
+   return f->stream - data;
+}
+
+stb_vorbis *stb_vorbis_open_pushdata(
+         unsigned char *data, int data_len, // the memory available for decoding
+         int *data_used,              // only defined if result is not NULL
+         int *error, stb_vorbis_alloc *alloc)
+{
+   stb_vorbis *f, p;
+   vorbis_init(&p, alloc);
+   p.stream     = data;
+   p.stream_end = data + data_len;
+   p.push_mode  = TRUE;
+   if (!start_decoder(&p)) {
+      if (p.eof)
+         *error = VORBIS_need_more_data;
+      else
+         *error = p.error;
+      return NULL;
+   }
+   f = vorbis_alloc(&p);
+   if (f) {
+      *f = p;
+      *data_used = f->stream - data;
+      *error = 0;
+      return f;
+   } else {
+      vorbis_deinit(&p);
+      return NULL;
+   }
+}
+#endif // STB_VORBIS_NO_PUSHDATA_API
+
+unsigned int stb_vorbis_get_file_offset(stb_vorbis *f)
+{
+   #ifndef STB_VORBIS_NO_PUSHDATA_API
+   if (f->push_mode) return 0;
+   #endif
+   if (USE_MEMORY(f)) return f->stream - f->stream_start;
+   #ifndef STB_VORBIS_NO_STDIO
+   return ftell(f->f) - f->f_start;
+   #endif
+}
+
+#ifndef STB_VORBIS_NO_PULLDATA_API
+//
+// DATA-PULLING API
+//
+
+static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last)
+{
+   for(;;) {
+      int n;
+      if (f->eof) return 0;
+      n = get8(f);
+      if (n == 0x4f) { // page header
+         unsigned int retry_loc = stb_vorbis_get_file_offset(f);
+         int i;
+         // check if we're off the end of a file_section stream
+         if (retry_loc - 25 > f->stream_len)
+            return 0;
+         // check the rest of the header
+         for (i=1; i < 4; ++i)
+            if (get8(f) != ogg_page_header[i])
+               break;
+         if (f->eof) return 0;
+         if (i == 4) {
+            uint8 header[27];
+            uint32 i, crc, goal, len;
+            for (i=0; i < 4; ++i)
+               header[i] = ogg_page_header[i];
+            for (; i < 27; ++i)
+               header[i] = get8(f);
+            if (f->eof) return 0;
+            if (header[4] != 0) goto invalid;
+            goal = header[22] + (header[23] << 8) + (header[24]<<16) + (header[25]<<24);
+            for (i=22; i < 26; ++i)
+               header[i] = 0;
+            crc = 0;
+            for (i=0; i < 27; ++i)
+               crc = crc32_update(crc, header[i]);
+            len = 0;
+            for (i=0; i < header[26]; ++i) {
+               int s = get8(f);
+               crc = crc32_update(crc, s);
+               len += s;
+            }
+            if (len && f->eof) return 0;
+            for (i=0; i < len; ++i)
+               crc = crc32_update(crc, get8(f));
+            // finished parsing probable page
+            if (crc == goal) {
+               // we could now check that it's either got the last
+               // page flag set, OR it's followed by the capture
+               // pattern, but I guess TECHNICALLY you could have
+               // a file with garbage between each ogg page and recover
+               // from it automatically? So even though that paranoia
+               // might decrease the chance of an invalid decode by
+               // another 2^32, not worth it since it would hose those
+               // invalid-but-useful files?
+               if (end)
+                  *end = stb_vorbis_get_file_offset(f);
+               if (last)
+                  if (header[5] & 0x04)
+                     *last = 1;
+                  else
+                     *last = 0;
+               set_file_offset(f, retry_loc-1);
+               return 1;
+            }
+         }
+        invalid:
+         // not a valid page, so rewind and look for next one
+         set_file_offset(f, retry_loc);
+      }
+   }
+}
+
+// seek is implemented with 'interpolation search'--this is like
+// binary search, but we use the data values to estimate the likely
+// location of the data item (plus a bit of a bias so when the
+// estimation is wrong we don't waste overly much time)
+
+#define SAMPLE_unknown  0xffffffff
+
+
+// ogg vorbis, in its insane infinite wisdom, only provides
+// information about the sample at the END of the page.
+// therefore we COULD have the data we need in the current
+// page, and not know it. we could just use the end location
+// as our only knowledge for bounds, seek back, and eventually
+// the binary search finds it. or we can try to be smart and
+// not waste time trying to locate more pages. we try to be
+// smart, since this data is already in memory anyway, so
+// doing needless I/O would be crazy!
+static int vorbis_analyze_page(stb_vorbis *f, ProbedPage *z)
+{
+   uint8 header[27], lacing[255];
+   uint8 packet_type[255];
+   int num_packet, packet_start, previous =0;
+   int i,len;
+   uint32 samples;
+
+   // record where the page starts
+   z->page_start = stb_vorbis_get_file_offset(f);
+
+   // parse the header
+   getn(f, header, 27);
+   assert(header[0] == 'O' && header[1] == 'g' && header[2] == 'g' && header[3] == 'S');
+   getn(f, lacing, header[26]);
+
+   // determine the length of the payload
+   len = 0;
+   for (i=0; i < header[26]; ++i)
+      len += lacing[i];
+
+   // this implies where the page ends
+   z->page_end = z->page_start + 27 + header[26] + len;
+
+   // read the last-decoded sample out of the data
+   z->last_decoded_sample = header[6] + (header[7] << 8) + (header[8] << 16) + (header[9] << 16);
+
+   if (header[5] & 4) {
+      // if this is the last page, it's not possible to work
+      // backwards to figure out the first sample! whoops! fuck.
+      z->first_decoded_sample = SAMPLE_unknown;
+      set_file_offset(f, z->page_start);
+      return 1;
+   }
+
+   // scan through the frames to determine the sample-count of each one...
+   // our goal is the sample # of the first fully-decoded sample on the
+   // page, which is the first decoded sample of the 2nd page
+
+   num_packet=0;
+
+   packet_start = ((header[5] & 1) == 0);
+
+   for (i=0; i < header[26]; ++i) {
+      if (packet_start) {
+         uint8 n,b,m;
+         if (lacing[i] == 0) goto bail; // trying to read from zero-length packet
+         n = get8(f);
+         // if bottom bit is non-zero, we've got corruption
+         if (n & 1) goto bail;
+         n >>= 1;
+         b = ilog(f->mode_count-1);
+         m = n >> b;
+         n &= (1 << b)-1;
+         if (n >= f->mode_count) goto bail;
+         if (num_packet == 0 && f->mode_config[n].blockflag)
+            previous = (m & 1);
+         packet_type[num_packet++] = f->mode_config[n].blockflag;
+         skip(f, lacing[i]-1);
+      } else
+         skip(f, lacing[i]);
+      packet_start = (lacing[i] < 255);
+   }
+
+   // now that we know the sizes of all the pages, we can start determining
+   // how much sample data there is.
+
+   samples = 0;
+
+   // for the last packet, we step by its whole length, because the definition
+   // is that we encoded the end sample loc of the 'last packet completed',
+   // where 'completed' refers to packets being split, and we are left to guess
+   // what 'end sample loc' means. we assume it means ignoring the fact that
+   // the last half of the data is useless without windowing against the next
+   // packet... (so it's not REALLY complete in that sense)
+   if (num_packet > 1)
+      samples += f->blocksize[packet_type[num_packet-1]];
+
+   for (i=num_packet-2; i >= 1; --i) {
+      // now, for this packet, how many samples do we have that
+      // do not overlap the following packet?
+      if (packet_type[i] == 1)
+         if (packet_type[i+1] == 1)
+            samples += f->blocksize_1 >> 1;
+         else
+            samples += ((f->blocksize_1 - f->blocksize_0) >> 2) + (f->blocksize_0 >> 1);
+      else
+         samples += f->blocksize_0 >> 1;
+   }
+   // now, at this point, we've rewound to the very beginning of the
+   // _second_ packet. if we entirely discard the first packet after
+   // a seek, this will be exactly the right sample number. HOWEVER!
+   // we can't as easily compute this number for the LAST page. The
+   // only way to get the sample offset of the LAST page is to use
+   // the end loc from the previous page. But what that returns us
+   // is _exactly_ the place where we get our first non-overlapped
+   // sample. (I think. Stupid spec for being ambiguous.) So for
+   // consistency it's better to do that here, too. However, that
+   // will then require us to NOT discard all of the first frame we
+   // decode, in some cases, which means an even weirder frame size
+   // and extra code. what a fucking pain.
+   
+   // we're going to discard the first packet if we
+   // start the seek here, so we don't care about it. (we could actually
+   // do better; if the first packet is long, and the previous packet
+   // is short, there's actually data in the first half of the first
+   // packet that doesn't need discarding... but not worth paying the
+   // effort of tracking that of that here and in the seeking logic)
+   // except crap, if we infer it from the _previous_ packet's end
+   // location, we DO need to use that definition... and we HAVE to
+   // infer the start loc of the LAST packet from the previous packet's
+   // end location. fuck you, ogg vorbis.
+
+   z->first_decoded_sample = z->last_decoded_sample - samples;
+
+   // restore file state to where we were
+   set_file_offset(f, z->page_start);
+   return 1;
+
+   // restore file state to where we were
+  bail:
+   set_file_offset(f, z->page_start);
+   return 0;
+}
+
+static int vorbis_seek_frame_from_page(stb_vorbis *f, uint32 page_start, uint32 first_sample, uint32 target_sample, int fine)
+{
+   int left_start, left_end, right_start, right_end, mode,i;
+   int frame=0;
+   uint32 frame_start;
+   int frames_to_skip, data_to_skip;
+
+   // first_sample is the sample # of the first sample that doesn't
+   // overlap the previous page... note that this requires us to
+   // _partially_ discard the first packet! bleh.
+   set_file_offset(f, page_start);
+
+   f->next_seg = -1;  // force page resync
+
+   frame_start = first_sample;
+   // frame start is where the previous packet's last decoded sample
+   // was, which corresponds to left_end... EXCEPT if the previous
+   // packet was long and this packet is short? Probably a bug here.
+
+
+   // now, we can start decoding frames... we'll only FAKE decode them,
+   // until we find the frame that contains our sample; then we'll rewind,
+   // and try again
+   for (;;) {
+      int start;
+
+      if (!vorbis_decode_initial(f, &left_start, &left_end, &right_start, &right_end, &mode))
+         return error(f, VORBIS_seek_failed);
+
+      if (frame == 0)
+         start = left_end;
+      else
+         start = left_start;
+
+      // the window starts at left_start; the last valid sample we generate
+      // before the next frame's window start is right_start-1
+      if (target_sample < frame_start + right_start-start)
+         break;
+
+      flush_packet(f);
+      if (f->eof)
+         return error(f, VORBIS_seek_failed);
+
+      frame_start += right_start - start;
+
+      ++frame;
+   }
+
+   // ok, at this point, the sample we want is contained in frame #'frame'
+
+   // to decode frame #'frame' normally, we have to decode the
+   // previous frame first... but if it's the FIRST frame of the page
+   // we can't. if it's the first frame, it means it falls in the part
+   // of the first frame that doesn't overlap either of the other frames.
+   // so, if we have to handle that case for the first frame, we might
+   // as well handle it for all of them, so:
+   if (target_sample > frame_start + (left_end - left_start)) {
+      // so what we want to do is go ahead and just immediately decode
+      // this frame, but then make it so the next get_frame_float() uses
+      // this already-decoded data? or do we want to go ahead and rewind,
+      // and leave a flag saying to skip the first N data? let's do that
+      frames_to_skip = frame;  // if this is frame #1, skip 1 frame (#0)
+      data_to_skip = left_end - left_start;
+   } else {
+      // otherwise, we want to skip frames 0, 1, 2, ... frame-2
+      // (which means frame-2+1 total frames) then decode frame-1,
+      // then leave frame pending
+      frames_to_skip = frame - 1;
+      assert(frames_to_skip >= 0);
+      data_to_skip = -1;      
+   }
+
+   set_file_offset(f, page_start);
+   f->next_seg = - 1; // force page resync
+
+   for (i=0; i < frames_to_skip; ++i) {
+      maybe_start_packet(f);
+      flush_packet(f);
+   }
+
+   if (data_to_skip >= 0) {
+      int i,j,n = f->blocksize_0 >> 1;
+      f->discard_samples_deferred = data_to_skip;
+      for (i=0; i < f->channels; ++i)
+         for (j=0; j < n; ++j)
+            f->previous_window[i][j] = 0;
+      f->previous_length = n;
+      frame_start += data_to_skip;
+   } else {
+      f->previous_length = 0;
+      vorbis_pump_first_frame(f);
+   }
+
+   // at this point, the NEXT decoded frame will generate the desired sample
+   if (fine) {
+      // so if we're doing sample accurate streaming, we want to go ahead and decode it!
+      if (target_sample != frame_start) {
+         int n;
+         stb_vorbis_get_frame_float(f, &n, NULL);
+         assert(target_sample > frame_start);
+         assert(f->channel_buffer_start + (int) (target_sample-frame_start) < f->channel_buffer_end);
+         f->channel_buffer_start += (target_sample - frame_start);
+      }
+   }
+
+   return 0;
+}
+
+static int vorbis_seek_base(stb_vorbis *f, unsigned int sample_number, int fine)
+{
+   ProbedPage p[2],q;
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+
+   // do we know the location of the last page?
+   if (f->p_last.page_start == 0) {
+      uint32 z = stb_vorbis_stream_length_in_samples(f);
+      if (z == 0) return error(f, VORBIS_cant_find_last_page);
+   }
+
+   p[0] = f->p_first;
+   p[1] = f->p_last;
+
+   if (sample_number >= f->p_last.last_decoded_sample)
+      sample_number = f->p_last.last_decoded_sample-1;
+
+   if (sample_number < f->p_first.last_decoded_sample) {
+      vorbis_seek_frame_from_page(f, p[0].page_start, 0, sample_number, fine);
+      return 0;
+   } else {
+      int attempts=0;
+      while (p[0].page_end < p[1].page_start) {
+         uint32 probe;
+         uint32 start_offset, end_offset;
+         uint32 start_sample, end_sample;
+
+         // copy these into local variables so we can tweak them
+         // if any are unknown
+         start_offset = p[0].page_end;
+         end_offset   = p[1].after_previous_page_start; // an address known to seek to page p[1]
+         start_sample = p[0].last_decoded_sample;
+         end_sample   = p[1].last_decoded_sample;
+
+         // currently there is no such tweaking logic needed/possible?
+         if (start_sample == SAMPLE_unknown || end_sample == SAMPLE_unknown)
+            return error(f, VORBIS_seek_failed);
+
+         // now we want to lerp between these for the target samples...
+      
+         // step 1: we need to bias towards the page start...
+         if (start_offset + 4000 < end_offset)
+            end_offset -= 4000;
+
+         // now compute an interpolated search loc
+         probe = start_offset + (int) floor((float) (end_offset - start_offset) / (end_sample - start_sample) * (sample_number - start_sample));
+
+         // next we need to bias towards binary search...
+         // code is a little wonky to allow for full 32-bit unsigned values
+         if (attempts >= 4) {
+            uint32 probe2 = start_offset + ((end_offset - start_offset) >> 1);
+            if (attempts >= 8)
+               probe = probe2;
+            else if (probe < probe2)
+               probe = probe + ((probe2 - probe) >> 1);
+            else
+               probe = probe2 + ((probe - probe2) >> 1);
+         }
+         ++attempts;
+
+         set_file_offset(f, probe);
+         if (!vorbis_find_page(f, NULL, NULL))   return error(f, VORBIS_seek_failed);
+         if (!vorbis_analyze_page(f, &q))        return error(f, VORBIS_seek_failed);
+         q.after_previous_page_start = probe;
+
+         // it's possible we've just found the last page again
+         if (q.page_start == p[1].page_start) {
+            p[1] = q;
+            continue;
+         }
+
+         if (sample_number < q.last_decoded_sample)
+            p[1] = q;
+         else
+            p[0] = q;
+      }
+
+      if (p[0].last_decoded_sample <= sample_number && sample_number < p[1].last_decoded_sample) {
+         vorbis_seek_frame_from_page(f, p[1].page_start, p[0].last_decoded_sample, sample_number, fine);
+         return 0;
+      }
+      return error(f, VORBIS_seek_failed);
+   }
+}
+
+int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number)
+{
+   return vorbis_seek_base(f, sample_number, FALSE);
+}
+
+int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)
+{
+   return vorbis_seek_base(f, sample_number, TRUE);
+}
+
+void stb_vorbis_seek_start(stb_vorbis *f)
+{
+   if (IS_PUSH_MODE(f)) { error(f, VORBIS_invalid_api_mixing); return; }
+   set_file_offset(f, f->first_audio_page_offset);
+   f->previous_length = 0;
+   f->first_decode = TRUE;
+   f->next_seg = -1;
+   vorbis_pump_first_frame(f);
+}
+
+unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)
+{
+   unsigned int restore_offset, previous_safe;
+   unsigned int end, last_page_loc;
+
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+   if (!f->total_samples) {
+      int last;
+      uint32 lo,hi;
+      char header[6];
+
+      // first, store the current decode position so we can restore it
+      restore_offset = stb_vorbis_get_file_offset(f);
+
+      // now we want to seek back 64K from the end (the last page must
+      // be at most a little less than 64K, but let's allow a little slop)
+      if (f->stream_len >= 65536 && f->stream_len-65536 >= f->first_audio_page_offset)
+         previous_safe = f->stream_len - 65536;
+      else
+         previous_safe = f->first_audio_page_offset;
+
+      set_file_offset(f, previous_safe);
+      // previous_safe is now our candidate 'earliest known place that seeking
+      // to will lead to the final page'
+
+      if (!vorbis_find_page(f, &end, (int unsigned *)&last)) {
+         // if we can't find a page, we're hosed!
+         f->error = VORBIS_cant_find_last_page;
+         f->total_samples = 0xffffffff;
+         goto done;
+      }
+
+      // check if there are more pages
+      last_page_loc = stb_vorbis_get_file_offset(f);
+
+      // stop when the last_page flag is set, not when we reach eof;
+      // this allows us to stop short of a 'file_section' end without
+      // explicitly checking the length of the section
+      while (!last) {
+         set_file_offset(f, end);
+         if (!vorbis_find_page(f, &end, (int unsigned *)&last)) {
+            // the last page we found didn't have the 'last page' flag
+            // set. whoops!
+            break;
+         }
+         previous_safe = last_page_loc+1;
+         last_page_loc = stb_vorbis_get_file_offset(f);
+      }
+
+      set_file_offset(f, last_page_loc);
+
+      // parse the header
+      getn(f, (unsigned char *)header, 6);
+      // extract the absolute granule position
+      lo = get32(f);
+      hi = get32(f);
+      if (lo == 0xffffffff && hi == 0xffffffff) {
+         f->error = VORBIS_cant_find_last_page;
+         f->total_samples = SAMPLE_unknown;
+         goto done;
+      }
+      if (hi)
+         lo = 0xfffffffe; // saturate
+      f->total_samples = lo;
+
+      f->p_last.page_start = last_page_loc;
+      f->p_last.page_end   = end;
+      f->p_last.last_decoded_sample = lo;
+      f->p_last.first_decoded_sample = SAMPLE_unknown;
+      f->p_last.after_previous_page_start = previous_safe;
+
+     done:
+      set_file_offset(f, restore_offset);
+   }
+   return f->total_samples == SAMPLE_unknown ? 0 : f->total_samples;
+}
+
+float stb_vorbis_stream_length_in_seconds(stb_vorbis *f)
+{
+   return stb_vorbis_stream_length_in_samples(f) / (float) f->sample_rate;
+}
+
+
+
+int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output)
+{
+   int len, right,left,i;
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+
+   if (!vorbis_decode_packet(f, &len, &left, &right)) {
+      f->channel_buffer_start = f->channel_buffer_end = 0;
+      return 0;
+   }
+
+   len = vorbis_finish_frame(f, len, left, right);
+   for (i=0; i < f->channels; ++i)
+      f->outputs[i] = f->channel_buffers[i] + left;
+
+   f->channel_buffer_start = left;
+   f->channel_buffer_end   = left+len;
+
+   if (channels) *channels = f->channels;
+   if (output)   *output = f->outputs;
+   return len;
+}
+
+#ifndef STB_VORBIS_NO_STDIO
+
+stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, stb_vorbis_alloc *alloc, unsigned int length)
+{
+   stb_vorbis *f, p;
+   vorbis_init(&p, alloc);
+   p.f = file;
+   p.f_start = ftell(file);
+   p.stream_len   = length;
+   p.close_on_free = close_on_free;
+   if (start_decoder(&p)) {
+      f = vorbis_alloc(&p);
+      if (f) {
+         *f = p;
+         vorbis_pump_first_frame(f);
+         return f;
+      }
+   }
+   if (error) *error = p.error;
+   vorbis_deinit(&p);
+   return NULL;
+}
+
+stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, stb_vorbis_alloc *alloc)
+{
+   unsigned int len, start;
+   start = ftell(file);
+   fseek(file, 0, SEEK_END);
+   len = ftell(file) - start;
+   fseek(file, start, SEEK_SET);
+   return stb_vorbis_open_file_section(file, close_on_free, error, alloc, len);
+}
+
+stb_vorbis * stb_vorbis_open_filename(char *filename, int *error, stb_vorbis_alloc *alloc)
+{
+   FILE *f = fopen(filename, "rb");
+   if (f) 
+      return stb_vorbis_open_file(f, TRUE, error, alloc);
+   if (error) *error = VORBIS_file_open_failure;
+   return NULL;
+}
+#endif // STB_VORBIS_NO_STDIO
+
+stb_vorbis * stb_vorbis_open_memory(unsigned char *data, int len, int *error, stb_vorbis_alloc *alloc)
+{
+   stb_vorbis *f, p;
+   if (data == NULL) return NULL;
+   vorbis_init(&p, alloc);
+   p.stream = data;
+   p.stream_end = data + len;
+   p.stream_start = p.stream;
+   p.stream_len = len;
+   p.push_mode = FALSE;
+   if (start_decoder(&p)) {
+      f = vorbis_alloc(&p);
+      if (f) {
+         *f = p;
+         vorbis_pump_first_frame(f);
+         return f;
+      }
+   }
+   if (error) *error = p.error;
+   vorbis_deinit(&p);
+   return NULL;
+}
+
+#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
+#define PLAYBACK_MONO     1
+#define PLAYBACK_LEFT     2
+#define PLAYBACK_RIGHT    4
+
+#define L  (PLAYBACK_LEFT  | PLAYBACK_MONO)
+#define C  (PLAYBACK_LEFT  | PLAYBACK_RIGHT | PLAYBACK_MONO)
+#define R  (PLAYBACK_RIGHT | PLAYBACK_MONO)
+
+static int8 channel_position[7][6] =
+{
+   { 0 },
+   { C },
+   { L, R },
+   { L, C, R },
+   { L, R, L, R },
+   { L, C, R, L, R },
+   { L, C, R, L, R, C },
+};
+
+
+#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT
+   typedef union {
+      float f;
+      int i;
+   } float_conv;
+   typedef char stb_vorbis_float_size_test[sizeof(float)==4 && sizeof(int) == 4];
+   #define FASTDEF(x) float_conv x
+   // add (1<<23) to convert to int, then divide by 2^SHIFT, then add 0.5/2^SHIFT to round
+   #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))
+   #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22))
+   #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s))
+   #define check_endianness()  
+#else
+   #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s))))
+   #define check_endianness()
+   #define FASTDEF(x)
+#endif
+
+static void copy_samples(short *dest, float *src, int len)
+{
+   int i;
+   check_endianness();
+   for (i=0; i < len; ++i) {
+      FASTDEF(temp);
+      int v = FAST_SCALED_FLOAT_TO_INT(temp, src[i],15);
+      if ((unsigned int) (v + 32768) > 65535)
+         v = v < 0 ? -32768 : 32767;
+      dest[i] = v;
+   }
+}
+
+static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len)
+{
+   #define BUFFER_SIZE  32
+   float buffer[BUFFER_SIZE];
+   int i,j,o,n = BUFFER_SIZE;
+   check_endianness();
+   for (o = 0; o < len; o += BUFFER_SIZE) {
+      memset(buffer, 0, sizeof(buffer));
+      if (o + n > len) n = len - o;
+      for (j=0; j < num_c; ++j) {
+         if (channel_position[num_c][j] & mask) {
+            for (i=0; i < n; ++i)
+               buffer[i] += data[j][d_offset+o+i];
+         }
+      }
+      for (i=0; i < n; ++i) {
+         FASTDEF(temp);
+         int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15);
+         if ((unsigned int) (v + 32768) > 65535)
+            v = v < 0 ? -32768 : 32767;
+         output[o+i] = v;
+      }
+   }
+}
+
+static int channel_selector[3][2] = { {0}, {PLAYBACK_MONO}, {PLAYBACK_LEFT, PLAYBACK_RIGHT} };
+static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len)
+{
+   #define BUFFER_SIZE  32
+   float buffer[BUFFER_SIZE];
+   int i,j,o,n = BUFFER_SIZE >> 1;
+   // o is the offset in the source data
+   check_endianness();
+   for (o = 0; o < len; o += BUFFER_SIZE >> 1) {
+      // o2 is the offset in the output data
+      int o2 = o << 1;
+      memset(buffer, 0, sizeof(buffer));
+      if (o + n > len) n = len - o;
+      for (j=0; j < num_c; ++j) {
+         int m = channel_position[num_c][j] & (PLAYBACK_LEFT | PLAYBACK_RIGHT);
+         if (m == (PLAYBACK_LEFT | PLAYBACK_RIGHT)) {
+            for (i=0; i < n; ++i) {
+               buffer[i*2+0] += data[j][d_offset+o+i];
+               buffer[i*2+1] += data[j][d_offset+o+i];
+            }
+         } else if (m == PLAYBACK_LEFT) {
+            for (i=0; i < n; ++i) {
+               buffer[i*2+0] += data[j][d_offset+o+i];
+            }
+         } else if (m == PLAYBACK_RIGHT) {
+            for (i=0; i < n; ++i) {
+               buffer[i*2+1] += data[j][d_offset+o+i];
+            }
+         }
+      }
+      for (i=0; i < (n<<1); ++i) {
+         FASTDEF(temp);
+         int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15);
+         if ((unsigned int) (v + 32768) > 65535)
+            v = v < 0 ? -32768 : 32767;
+         output[o2+i] = v;
+      }
+   }
+}
+
+static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples)
+{
+   int i;
+   if (buf_c != data_c && buf_c <= 2 && data_c <= 6) {
+      static int channel_selector[3][2] = { {0}, {PLAYBACK_MONO}, {PLAYBACK_LEFT, PLAYBACK_RIGHT} };
+      for (i=0; i < buf_c; ++i)
+         compute_samples(channel_selector[buf_c][i], buffer[i]+b_offset, data_c, data, d_offset, samples);
+   } else {
+      int limit = buf_c < data_c ? buf_c : data_c;
+      for (i=0; i < limit; ++i)
+         copy_samples(buffer[i]+b_offset, data[i], samples);
+      for (   ; i < buf_c; ++i)
+         memset(buffer[i]+b_offset, 0, sizeof(short) * samples);
+   }
+}
+
+int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples)
+{
+   float **output;
+   int len = stb_vorbis_get_frame_float(f, NULL, &output);
+   if (len > num_samples) len = num_samples;
+   if (len)
+      convert_samples_short(num_c, buffer, 0, f->channels, output, 0, len);
+   return len;
+}
+
+static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len)
+{
+   int i;
+   check_endianness();
+   if (buf_c != data_c && buf_c <= 2 && data_c <= 6) {
+      assert(buf_c == 2);
+      for (i=0; i < buf_c; ++i)
+         compute_stereo_samples(buffer, data_c, data, d_offset, len);
+   } else {
+      int limit = buf_c < data_c ? buf_c : data_c;
+      int j;
+      for (j=0; j < len; ++j) {
+         for (i=0; i < limit; ++i) {
+            FASTDEF(temp);
+            float f = data[i][d_offset+j];
+            int v = FAST_SCALED_FLOAT_TO_INT(temp, f,15);//data[i][d_offset+j],15);
+            if ((unsigned int) (v + 32768) > 65535)
+               v = v < 0 ? -32768 : 32767;
+            *buffer++ = v;
+         }
+         for (   ; i < buf_c; ++i)
+            *buffer++ = 0;
+      }
+   }
+}
+
+int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts)
+{
+   float **output;
+   int len;
+   if (num_c == 1) return stb_vorbis_get_frame_short(f,num_c,&buffer, num_shorts);
+   len = stb_vorbis_get_frame_float(f, NULL, &output);
+   if (len) {
+      if (len*num_c > num_shorts) len = num_shorts / num_c;
+      convert_channels_short_interleaved(num_c, buffer, f->channels, output, 0, len);
+   }
+   return len;
+}
+
+int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts)
+{
+   float **outputs;
+   int len = num_shorts / channels;
+   int n=0;
+   int z = f->channels;
+   if (z > channels) z = channels;
+   while (n < len) {
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= len) k = len - n;
+      if (k)
+         convert_channels_short_interleaved(channels, buffer, f->channels, f->channel_buffers, f->channel_buffer_start, k);
+      buffer += k*channels;
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == len) break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break;
+   }
+   return n;
+}
+
+int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len)
+{
+   float **outputs;
+   int n=0;
+   int z = f->channels;
+   if (z > channels) z = channels;
+   while (n < len) {
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= len) k = len - n;
+      if (k)
+         convert_samples_short(channels, buffer, n, f->channels, f->channel_buffers, f->channel_buffer_start, k);
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == len) break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break;
+   }
+   return n;
+}
+
+#ifndef STB_VORBIS_NO_STDIO
+int stb_vorbis_decode_filename(char *filename, int *channels, short **output)
+{
+   int data_len, offset, total, limit, error;
+   short *data;
+   stb_vorbis *v = stb_vorbis_open_filename(filename, &error, NULL);
+   if (v == NULL) return -1;
+   limit = v->channels * 4096;
+   *channels = v->channels;
+   offset = data_len = 0;
+   total = limit;
+   data = (short *) malloc(total * sizeof(*data));
+   if (data == NULL) {
+      stb_vorbis_close(v);
+      return -2;
+   }
+   for (;;) {
+      int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset);
+      if (n == 0) break;
+      data_len += n;
+      offset += n * v->channels;
+      if (offset + limit > total) {
+         short *data2;
+         total *= 2;
+         data2 = (short *) realloc(data, total * sizeof(*data));
+         if (data2 == NULL) {
+            free(data);
+            stb_vorbis_close(v);
+            return -2;
+         }
+         data = data2;
+      }
+   }
+   *output = data;
+   return data_len;
+}
+#endif // NO_STDIO
+
+int stb_vorbis_decode_memory(uint8 *mem, int len, int *channels, short **output)
+{
+   int data_len, offset, total, limit, error;
+   short *data;
+   stb_vorbis *v = stb_vorbis_open_memory(mem, len, &error, NULL);
+   if (v == NULL) return -1;
+   limit = v->channels * 4096;
+   *channels = v->channels;
+   offset = data_len = 0;
+   total = limit;
+   data = (short *) malloc(total * sizeof(*data));
+   if (data == NULL) {
+      stb_vorbis_close(v);
+      return -2;
+   }
+   for (;;) {
+      int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset);
+      if (n == 0) break;
+      data_len += n;
+      offset += n * v->channels;
+      if (offset + limit > total) {
+         short *data2;
+         total *= 2;
+         data2 = (short *) realloc(data, total * sizeof(*data));
+         if (data2 == NULL) {
+            free(data);
+            stb_vorbis_close(v);
+            return -2;
+         }
+         data = data2;
+      }
+   }
+   *output = data;
+   return data_len;
+}
+#endif
+
+int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats)
+{
+   float **outputs;
+   int len = num_floats / channels;
+   int n=0;
+   int z = f->channels;
+   if (z > channels) z = channels;
+   while (n < len) {
+      int i,j;
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= len) k = len - n;
+      for (j=0; j < k; ++j) {
+         for (i=0; i < z; ++i)
+            *buffer++ = f->channel_buffers[i][f->channel_buffer_start+j];
+         for (   ; i < channels; ++i)
+            *buffer++ = 0;
+      }
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == len) break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break;
+   }
+   return n;
+}
+
+int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples)
+{
+   float **outputs;
+   int n=0;
+   int z = f->channels;
+   if (z > channels) z = channels;
+   while (n < num_samples) {
+      int i;
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= num_samples) k = num_samples - n;
+      if (k) {
+         for (i=0; i < z; ++i)
+            memcpy(buffer[i]+n, f->channel_buffers+f->channel_buffer_start, sizeof(float)*k);
+         for (   ; i < channels; ++i)
+            memset(buffer[i]+n, 0, sizeof(float) * k);
+      }
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == num_samples) break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break;
+   }
+   return n;
+}
+#endif // STB_VORBIS_NO_PULLDATA_API
+
+#endif // STB_VORBIS_HEADER_ONLY

tests/stb.c

@@ -0,0 +1,3403 @@
+/*
+ * Unit tests for "stb.h"
+ */
+
+//#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#ifdef _WIN32
+#include <crtdbg.h>
+#endif
+
+#define STB_STUA
+//#define STB_FASTMALLOC
+#ifdef _DEBUG
+#define STB_MALLOC_WRAPPER_DEBUG
+#endif
+#define STB_NPTR
+#include "stb.h"
+#include "stb_file.h"
+#include "stb_pixel32.h"
+
+//#define DEBUG_BLOCK
+#ifdef DEBUG_BLOCK
+#include <conio.h>
+#endif
+
+#ifdef STB_FASTMALLOC
+#error "can't use FASTMALLOC with threads"
+#endif
+
+int count;
+void c(int truth, char *error)
+{
+   if (!truth) {
+      fprintf(stderr, "Test failed: %s\n", error);
+      ++count;
+   }
+}
+
+
+#if 0
+void show(void)
+{
+   #ifdef _WIN32
+   SYSTEM_INFO x;
+   GetSystemInfo(&x);
+   printf("%d\n", x.dwPageSize);
+   #endif
+}
+#endif
+
+void test_classes(void)
+{
+   unsigned char size_base[32], size_shift[32];
+   int class_to_pages[256];
+   int class_to_size[256], cl;
+   int lg, size, wasted_pages;
+   int kAlignShift = 3;
+   int kAlignment = 1 << kAlignShift;
+   int kMaxSize = 8 * 4096;
+   int kPageShift = 12;
+   int kPageSize = (1 << kPageShift);
+  int next_class = 1;
+  int alignshift = kAlignShift;
+  int last_lg = -1;
+
+  for (lg = 0; lg < kAlignShift; lg++) {
+    size_base[lg] = 1;
+    size_shift[lg] = kAlignShift;
+  }
+
+  for (size = kAlignment; size <= kMaxSize; size += (1 << alignshift)) {
+    int lg = stb_log2_floor(size);
+    if (lg > last_lg) {
+      // Increase alignment every so often.
+      //
+      // Since we double the alignment every time size doubles and
+      // size >= 128, this means that space wasted due to alignment is
+      // at most 16/128 i.e., 12.5%.  Plus we cap the alignment at 256
+      // bytes, so the space wasted as a percentage starts falling for
+      // sizes > 2K.
+      if ((lg >= 7) && (alignshift < 8)) {
+        alignshift++;
+      }
+      size_base[lg] = next_class - ((size-1) >> alignshift);
+      size_shift[lg] = alignshift;
+    }
+
+    class_to_size[next_class] = size;
+    last_lg = lg;
+
+    next_class++;
+  }
+
+  // Initialize the number of pages we should allocate to split into
+  // small objects for a given class.
+  wasted_pages = 0;
+  for (cl = 1; cl < next_class; cl++) {
+    // Allocate enough pages so leftover is less than 1/8 of total.
+    // This bounds wasted space to at most 12.5%.
+    size_t psize = kPageSize;
+    const size_t s = class_to_size[cl];
+    while ((psize % s) > (psize >> 3)) {
+      psize += kPageSize;
+    }
+    class_to_pages[cl] = psize >> kPageShift;
+    wasted_pages += psize;
+  }
+
+  printf("TCMalloc can waste as much as %d memory on one-shot allocations\n", wasted_pages);
+
+
+  return;
+}
+
+
+void test_script(void)
+{
+   stua_run_script(
+      "var g = (2+3)*5 + 3*(2+1) + ((7)); \n"
+      "func sprint(x) _print(x) _print(' ') x end;\n"
+      "func foo(y) var q = func(x) sprint(x) end; q end;\n "
+      "var z=foo(5); z(77);\n"
+      "func counter(z) func(x) z=z+1 end end\n"
+      "var q=counter(0), p=counter(5);\n"
+      "sprint(q()) sprint(p()) sprint(q()) sprint(p()) sprint(q()) sprint(p())\n"
+      "var x=2222;\n"
+      "if 1 == 2 then 3333 else 4444 end; => x; sprint(x);\n"
+      "var x1 = sprint(1.5e3);  \n"
+      "var x2 = sprint(.5);  \n"
+      "var x3 = sprint(1.);  \n"
+      "var x4 = sprint(1.e3);  \n"
+      "var x5 = sprint(1e3);  \n"
+      "var x6 = sprint(0.5e3);  \n"
+      "var x7 = sprint(.5e3);  \n"
+      " func sum(x,y) x+y end                                       \n"
+      " func sumfunc(a) sum+{x=a} end                               \n"
+      " var q = sumfunc(3) \n"
+      " var p = sumfunc(20) \n"
+      " var d = sprint(q(5)) - sprint(q(8)) \n"
+      " var e = sprint(p(5)) - sprint(p(8)) \n"
+      " func test3(x)       \n"
+      "    sprint(x)         \n"
+      "    x = x+3          \n"
+      "    sprint(x)         \n"
+      "    x+5              \n"
+      " end                 \n"
+      " var y = test3(4);   \n"
+      " func fib(x)         \n"
+      "    if x < 3 then    \n"
+      "       1             \n"
+      "    else             \n"
+      "      fib(x-1) + fib(x-2); \n"
+      "    end              \n"
+      " end                 \n"
+      "                     \n"
+      " func fib2(x)        \n"
+      "    var a=1          \n"
+      "    var b=1          \n"
+      "    sprint(a)        \n"
+      "    sprint(b)        \n"
+      "    while x > 2 do   \n"
+      "       var c=a+b     \n"
+      "       a=b           \n"
+      "       b=c           \n"
+      "       sprint(b)     \n"
+      "       x=x-1         \n"
+      "    end              \n"
+      "    b                \n"
+      " end                 \n"
+      "                                                             \n"
+      " func assign(z)                                              \n"
+      "    var y = { 'this', 'is', 'a', 'lame', 'day', 'to', 'die'} \n"
+      "    y[3] = z                                                 \n"
+      "    var i = 0                                                \n"
+      "    while y[i] != nil do                                     \n"
+      "       sprint(y[i])                                          \n"
+      "       i = i+1                                               \n"
+      "    end                                                      \n"
+      " end                                                         \n"
+      "                                                             \n"
+      " sprint(fib(12)); \n"
+      " assign(\"good\"); \n"
+      " fib2(20); \n"
+      " sprint('ok'); \n"
+      " sprint(-5); \n"
+      " // final comment with no newline"
+   );
+}
+
+#ifdef STB_THREADS
+extern void __stdcall Sleep(unsigned long);
+
+void * thread_1(void *x)
+{
+   Sleep(80);
+   printf("thread 1\n"); fflush(stdout);
+   return (void *) 2;
+}
+
+void * thread_2(void *y)
+{
+   stb_work(thread_1, NULL, y);
+   Sleep(50);
+   printf("thread 2\n"); fflush(stdout);
+   return (void *) 3;
+}
+
+stb_semaphore stest;
+stb_mutex mutex;
+volatile int tc1, tc2;
+
+void *thread_3(void *p)
+{
+   stb_mutex_begin(mutex);
+   ++tc1;
+   stb_mutex_end(mutex);
+   stb_sem_waitfor(stest);
+   stb_mutex_begin(mutex);
+   ++tc2;
+   stb_mutex_end(mutex);
+   return NULL;
+}
+
+void test_threads(void)
+{
+   volatile int a=0,b=0;
+   //stb_work_numthreads(2);
+   stb_work(thread_2, (void *) &a, (void *) &b);
+   while (a==0 || b==0) {
+      Sleep(10);
+      //printf("a=%d b=%d\n", a, b);
+   }
+   c(a==2 && b == 3, "stb_thread");
+   stb_work_numthreads(4);
+   stest = stb_sem_new(8);
+   mutex = stb_mutex_new();
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   while (tc1 < 4)
+      Sleep(10);
+   c(tc1 == 4, "stb_work 1");
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   Sleep(40);
+   while (tc1 != 8 || tc2 != 8)
+      Sleep(10);
+   c(tc1 == 8 && tc2 == 8, "stb_work 2");
+   stb_work_numthreads(2);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   stb_work(thread_3, NULL, NULL);
+   while (tc1 < 10)
+      Sleep(10);
+   c(tc1 == 10, "stb_work 1");
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+   stb_sem_release(stest);
+
+   Sleep(100);
+   stb_sem_delete(stest);
+   stb_mutex_delete(mutex);
+}
+#else
+void test_threads(void)
+{
+}
+#endif
+
+void *thread4(void *p)
+{
+   return NULL;
+}
+
+#ifdef STB_THREADS
+stb_threadqueue *tq;
+stb_sync synch;
+stb_mutex msum;
+
+volatile int thread_sum;
+
+void *consume1(void *p)
+{
+   volatile int *q = (volatile int *) p;
+   for(;;) {
+      int z;
+      stb_threadq_get_block(tq, &z);
+      stb_mutex_begin(msum);
+      thread_sum += z;
+      *q += z;
+      stb_mutex_end(msum);
+      stb_sync_reach(synch);
+   }      
+}
+
+void test_threads2(void)
+{
+   int array[256],i,n=0;
+   volatile int which[4];
+   synch = stb_sync_new();
+   stb_sync_set_target(synch,2);
+   stb_work_reach(thread4, NULL, NULL, synch);
+   stb_sync_reach_and_wait(synch);
+   printf("ok\n");
+
+   tq = stb_threadq_new(4, 1, TRUE,TRUE);
+   msum = stb_mutex_new();
+   thread_sum = 0;
+   stb_sync_set_target(synch, 65);
+   for (i=0; i < 4; ++i) {
+      which[i] = 0;
+      stb_create_thread(consume1, (int *) &which[i]);
+   }
+   for (i=1; i <= 64; ++i) {
+      array[i] = i;
+      n += i;
+      stb_threadq_add_block(tq, &array[i]);
+   }
+   stb_sync_reach_and_wait(synch);
+   stb_barrier();
+   c(thread_sum == n, "stb_threadq 1");
+   c(which[0] + which[1] + which[2] + which[3] == n, "stb_threadq 2");
+   printf("(Distribution: %d %d %d %d)\n", which[0], which[1], which[2], which[3]);
+
+   stb_sync_delete(synch);
+   stb_threadq_delete(tq);
+   stb_mutex_delete(msum);
+}
+#else
+void test_threads2(void)
+{
+}
+#endif
+
+char tc[] = "testing compression test quick test voila woohoo what the hell";
+
+char storage1[1 << 23];
+int test_compression(char *buffer, int length)
+{
+   char *storage2;
+   int c_len = stb_compress(storage1, buffer, length);
+   int dc_len;
+   printf("Compressed %d to %d\n", length, c_len);
+   dc_len = stb_decompress_length(storage1);
+   storage2 = malloc(dc_len);
+   dc_len = stb_decompress(storage2, storage1, c_len);
+   if (dc_len != length) { free(storage2); return -1; }
+   if (memcmp(buffer, storage2, length) != 0) { free(storage2); return -1; }
+   free(storage2);
+   return c_len;
+}
+
+#if 0
+int test_en_compression(char *buffer, int length)
+{
+   int c_len = stb_en_compress(storage1, buffer, length);
+   int dc_len;
+   printf("Encompressed %d to %d\n", length, c_len);
+   dc_len = stb_en_decompress(storage2, storage1, c_len);
+   if (dc_len != length) return -1;
+   if (memcmp(buffer, storage2, length) != 0) return -1;
+   return c_len;
+}
+#endif
+
+#define STR_x "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+#define STR_y "yyyyyyyyyyyyyyyyyy"
+
+#define STR_xy STR_x STR_y
+#define STR_xyyxy STR_xy STR_y STR_xy
+
+#define STR_1 "testing"
+#define STR_2 STR_xyyxy STR_xy STR_xyyxy STR_xyyxy STR_xy STR_xyyxy
+#define STR_3 "buh"
+
+char buffer[] = STR_1 "\r\n" STR_2 STR_2 STR_2 "\n" STR_3;
+char str1[] = STR_1;
+char str2[] = STR_2 STR_2 STR_2;
+char str3[] = STR_3;
+
+int sum(short *s)
+{
+   int i,total=0;
+   for (i=0; i < stb_arr_len(s); ++i)
+      total += s[i];
+   return total;
+}
+
+stb_uint stb_adler32_old(stb_uint adler32, stb_uchar *buffer, stb_uint buflen)
+{
+   const stb_uint ADLER_MOD = 65521;
+   stb_uint s1 = adler32 & 0xffff;
+   stb_uint s2 = adler32 >> 16;
+
+   while (buflen-- > 0) { // NOTE: much faster implementations are possible!
+      s1 += *buffer++; if (s1 > ADLER_MOD) s1 -= ADLER_MOD;
+      s2 += s1       ; if (s2 > ADLER_MOD) s2 -= ADLER_MOD;
+   }
+   return (s2 << 16) + s1;
+}
+
+static int sample_test[3][5] =
+{
+   { 1,2,3,4,5 },
+   { 6,7,8,9,10, },
+   { 11,12,13,14,15 },
+};
+
+typedef struct { unsigned short x,y,z; } struct1;
+typedef struct { double a; int x,y,z; } struct2;
+
+char *args_raw[] = { "foo", "-dxrf", "bar", "-ts" };
+char *args[8];
+
+void do_compressor(int,char**);
+void test_sha1(void);
+
+int alloc_num, alloc_size;
+void dumpfunc(void *ptr, int sz, char *file, int line)
+{
+   printf("%p (%6d)  -- %3d:%s\n", ptr, sz, line, file);
+   alloc_size += sz;
+   alloc_num  += 1;
+}
+
+char *expects(stb_matcher *m, char *s, int result, int len, char *str)
+{
+   int res2,len2=0;
+   res2 = stb_lex(m, s, &len2);
+   c(result == res2 && len == len2, str);
+   return s + len;
+}
+
+void test_lex(void)
+{
+   stb_matcher *m = stb_lex_matcher();
+   //         tok_en5 .3 20.1 20. .20 .1
+   char *s = "tok_en5.3 20.1 20. .20.1";
+
+   stb_lex_item(m, "[a-zA-Z_][a-zA-Z0-9_]*", 1   );
+   stb_lex_item(m, "[0-9]*\\.?[0-9]*"      , 2   );
+   stb_lex_item(m, "[\r\n\t ]+"            , 3   );
+   stb_lex_item(m, "."                     , -99 );
+   s=expects(m,s,1,7, "stb_lex 1");
+   s=expects(m,s,2,2, "stb_lex 2");
+   s=expects(m,s,3,1, "stb_lex 3");
+   s=expects(m,s,2,4, "stb_lex 4");
+   s=expects(m,s,3,1, "stb_lex 5");
+   s=expects(m,s,2,3, "stb_lex 6");
+   s=expects(m,s,3,1, "stb_lex 7");
+   s=expects(m,s,2,3, "stb_lex 8");
+   s=expects(m,s,2,2, "stb_lex 9");
+   s=expects(m,s,0,0, "stb_lex 10");
+   stb_matcher_free(m);
+}
+
+typedef struct Btest
+{
+   struct Btest stb_bst_fields(btest_);
+   int v;
+} Btest;
+
+stb_bst(Btest, btest_, BT2,bt2,v, int, a - b)
+
+void bst_test(void)
+{
+   Btest *root = NULL, *t;
+   int items[500], sorted[500];
+   int i,j,z;
+   for (z=0; z < 10; ++z) {
+      for (i=0; i < 500; ++i)
+         items[i] = stb_rand() & 0xfffffff;
+
+      // check for collisions, and retrry if so
+      memcpy(sorted, items, sizeof(sorted));
+      qsort(sorted, 500, sizeof(sorted[0]), stb_intcmp(0));
+      for (i=1; i < 500; ++i)
+         if (sorted[i-1] == sorted[i])
+            break;
+      if (i != 500) { --z; break; }
+
+      for (i=0; i < 500; ++i)  {
+         t = malloc(sizeof(*t));
+         t->v = items[i];
+         root = btest_insert(root, t);
+         #ifdef STB_DEBUG
+         btest__validate(root,1);
+         #endif
+         for (j=0; j <= i; ++j)
+            c(btest_find(root, items[j]) != NULL, "stb_bst 1");
+         for (   ; j < 500; ++j)
+            c(btest_find(root, items[j]) == NULL, "stb_bst 2");
+      }
+
+      t = btest_first(root);
+      for (i=0; i < 500; ++i)
+         t = btest_next(root,t);
+      c(t == NULL, "stb_bst 5");
+      t = btest_last(root);
+      for (i=0; i < 500; ++i)
+         t = btest_prev(root,t);
+      c(t == NULL, "stb_bst 6");
+
+      memcpy(sorted, items, sizeof(sorted));
+      qsort(sorted, 500, sizeof(sorted[0]), stb_intcmp(0));
+      t = btest_first(root);
+      for (i=0; i < 500; ++i) {
+         assert(t->v == sorted[i]);
+         t = btest_next(root, t);
+      }
+      assert(t == NULL);
+
+      if (z==1)
+         stb_reverse(items, 500, sizeof(items[0]));
+      else if (z)
+         stb_shuffle(items, 500, sizeof(items[0]), stb_rand());
+
+      for (i=0; i < 500; ++i)  {
+         t = btest_find(root, items[i]);
+         assert(t != NULL);
+         root = btest_remove(root, t);
+         c(btest_find(root, items[i]) == NULL, "stb_bst 5");
+         #ifdef STB_DEBUG
+         btest__validate(root, 1);
+         #endif
+         for (j=0; j <= i; ++j)
+            c(btest_find(root, items[j]) == NULL, "stb_bst 3");
+         for (   ; j < 500; ++j)
+            c(btest_find(root, items[j]) != NULL, "stb_bst 4");
+         free(t);
+      }
+   }
+}
+
+#define BN 800
+unsigned int bloc[BN];
+char *data[BN];
+int   dlen[BN];
+
+int bcheck(stb_blockfile *b, int n)
+{
+   char temp[2048];
+   if (!stb_blockfile_read(b, temp, bloc[n], dlen[n])) {
+      c(0, "blockfile_test read error");
+      bloc[n] = 0;
+      return 0;
+   }
+   if (memcmp(temp, data[n], dlen[n])) {
+      c(0, "blockfile_test read");
+      bloc[n] = 0;
+      return 0;
+   }
+   return 1;
+}
+
+void blockfile_test(void)
+{
+   int inuse=0, max_inuse=0;
+   int i,j,freespace=0;
+   int z;
+   stb_blockfile *b;
+   int o[BN];
+
+   b = stb_blockfile_open("btest.bin", 1);
+
+   for (i=0; i < BN; ++i) {
+      bloc[i] = 0;
+      dlen[i] = stb_rand() % 500 + 50;
+      data[i] = malloc(1024);
+      for (j=0; j < dlen[i]; ++j)
+         data[i][j] = (char) stb_rand();
+   }
+
+   for(z=0; z < 50; ++z) {
+      if (z % 4 == 3) {
+         //if (!b->dirty_flag) stb__dirty(b);
+         stb_blockfile_close(b);
+         b = stb_blockfile_open("btest.bin", 0);
+         //if (!b->dirty_flag) stb__dirty(b);
+      }
+      for (i=0; i < BN; ++i) o[i] = i;
+      stb_shuffle(o, BN, sizeof(o[0]), stb_rand());
+      for (i=0; i < BN; ++i) {
+         int n = o[i];
+         if (bloc[n] > 0) {
+            // first check it
+            if (!bcheck(b,n)) continue;
+            if (stb_rand() % 100 > 75) {
+               stb_blockfile_free(b, bloc[n], dlen[n]);
+               bloc[n] = 0;
+               inuse -= dlen[n];
+            } else if (stb_rand() % 100 > 75) {
+               int olen = dlen[n];
+               dlen[n] = stb_rand() % 500 + 50;
+               for (j=0; j < dlen[n]; ++j)
+                  data[n][j] = (char) stb_rand();
+               bloc[n] = stb_blockfile_rewrite(b, data[n], dlen[n], bloc[n], olen);
+               inuse = inuse + dlen[n] - olen;
+            }
+         } else {
+            if (stb_rand() % 100 > 40) {
+               bloc[n] = stb_blockfile_write(b, data[n], dlen[n]);
+               assert(bloc[n]);
+               inuse += dlen[n];
+            }
+         }
+         if (inuse > max_inuse) max_inuse = inuse;
+      }
+      #ifdef DEBUG_BLOCK
+      printf("Pass %d\n", z+1);
+      stb_block_compact_freelist(b->manager);
+      qsort(b->manager->freelist, b->manager->len, 8, stb__freelist_compare);
+      for (i=0; i < b->manager->len; ++i)
+         printf("%9d %9d\n", b->manager->freelist[i].start, b->manager->freelist[i].len);
+      _getch();
+      #endif
+   }
+
+   freespace = 0;
+   for (i=0; i < b->manager->len; ++i)
+      freespace += b->manager->freelist[i].len;
+
+   printf("Max data: %d; Inuse: %d; freespace: %d (%d)\n", max_inuse, inuse, freespace, b->manager->len);
+   stb_blockfile_close(b);
+
+   for (i=0; i < BN; ++i)
+      free(data[i]);
+}
+
+extern void stu_uninit(void);
+
+stb_define_sort(sort_int, int, *a < *b)
+
+stb_rand_define(prime_rand, 1)
+void test_packed_floats(void);
+void test_parser_generator(void);
+
+void rec_print(stb_dirtree2 *d, int depth)
+{
+   int i;
+   for (i=0; i < depth; ++i) printf("  ");
+   printf("%s (%d)\n", d->relpath, stb_arr_len(d->files));
+   for (i=0; i < stb_arr_len(d->subdirs); ++i)
+      rec_print(d->subdirs[i], depth+1);
+   d->weight = (float) stb_arr_len(d->files);
+}
+
+int main(int argc, char **argv)
+{
+   char *z;
+   stb__wchar buffer7[1024],buffer9[1024];
+   char buffer8[4096];
+   FILE *f;
+   char *p1 = "foo/bar\\baz/test.xyz";
+   char *p2 = "foo/.bar";
+   char *p3 = "foo.bar";
+   char *p4 = "foo/bar";
+   char *wildcards[] = { "*foo*", "*bar", "baz", "*1*2*3*", "*/CVS/repository", "*oof*" };
+   char **s;
+   char buf[256], *p;
+   int n,len2,*q,i;
+   stb_mml *m;
+   stb_matcher *mt=NULL;
+
+   if (argc > 1) {
+      do_compressor(argc,argv);
+      return 0;
+   }
+   test_classes();
+   //show();
+
+   //stb_malloc_check_counter(2,2);
+   //_CrtSetBreakAlloc(10398);
+
+   stbprint("Checking {!if} the {$fancy} print function {#works}?  - should\n");
+   stbprint("                                                      - align\n");
+   stbprint("But {#3this}} {one}}                                  - shouldn't\n");
+
+   #if 0
+   {
+      int i;
+      char **s = stb_readdir_recursive("/sean", NULL);
+      stb_dirtree *d = stb_dirtree_from_files_relative("", s, stb_arr_len(s));
+      stb_dirtree **e;
+      rec_print(d, 0);
+      e = stb_summarize_tree(d,12,4);
+      for (i=0; i < stb_arr_len(e); ++i) {
+         printf("%s\n", e[i]->fullpath);
+      }
+      stb_arr_free(e);
+
+      stb_fatal("foo");
+   }
+   #endif
+
+   stb_("Started stb.c");
+   test_threads2();
+   test_threads();
+
+   for (i=0; i < 1023 && 5+77*i < 0xd800; ++i)
+      buffer7[i] = 5+77*i;
+   buffer7[i++] = 0xd801;
+   buffer7[i++] = 0xdc02;
+   buffer7[i++] = 0xdbff;
+   buffer7[i++] = 0xdfff;
+   buffer7[i] = 0;
+   p = stb_to_utf8(buffer8, buffer7, sizeof(buffer8));
+   c(p != NULL, "stb_to_utf8");
+   if (p != NULL) {
+      stb_from_utf8(buffer9, buffer8, sizeof(buffer9)/2);
+      c(!memcmp(buffer7, buffer9, i*2), "stb_from_utf8");
+   }
+
+   z = "foo.*[bd]ak?r";
+   c( stb_regex(z, "muggle man food is barfy") == 1, "stb_regex 1");
+   c( stb_regex("foo.*bar", "muggle man food is farfy") == 0, "stb_regex 2");
+   c( stb_regex("[^a-zA-Z]foo[^a-zA-Z]", "dfoobar xfood") == 0, "stb_regex 3");
+   c( stb_regex(z, "muman foob is bakrfy") == 1, "stb_regex 4");
+   z = "foo.*[bd]bk?r";
+   c( stb_regex(z, "muman foob is bakrfy") == 0, "stb_regex 5");
+   c( stb_regex(z, "muman foob is bbkrfy") == 1, "stb_regex 6");
+
+   stb_regex(NULL,NULL);
+
+   #if 0
+   test_parser_generator();
+   stb_wrapper_listall(dumpfunc);
+   if (alloc_num) 
+      printf("Memory still in use: %d allocations of %d bytes.\n", alloc_num, alloc_size);
+   #endif
+
+   test_script();
+   p = stb_file("sieve.stua", NULL);
+   if (p) {
+      stua_run_script(p);      
+      free(p);
+   }
+   stua_uninit();
+
+   //stb_wrapper_listall(dumpfunc);
+   printf("Memory still in use: %d allocations of %d bytes.\n", alloc_num, alloc_size);
+
+   c(stb_alloc_count_alloc == stb_alloc_count_free, "stb_alloc 0");
+
+   bst_test();
+
+   c(stb_alloc_count_alloc == stb_alloc_count_free, "stb_alloc 0");
+
+   // stb_block
+   {
+      int inuse=0, freespace=0;
+      int *x = malloc(10000*sizeof(*x));
+      stb_block *b = stb_block_new(1, 10000);
+      #define BLOCK_COUNT  1000
+      int *p = malloc(sizeof(*p) * BLOCK_COUNT);
+      int *l = malloc(sizeof(*l) * BLOCK_COUNT);
+      int i, n, k = 0;
+
+      memset(x, 0, 10000 * sizeof(*x));
+
+      n = 0;
+      while (n < BLOCK_COUNT && k < 1000) {
+         l[n] = 16 + (rand() & 31);
+         p[n] = stb_block_alloc(b, l[n], 0);
+         if (p[n] == 0)
+            break;
+         inuse += l[n];
+
+         freespace = 0;
+         for (i=0; i < b->len; ++i)
+            freespace += b->freelist[i].len;
+         assert(freespace + inuse == 9999);
+
+         for (i=0; i < l[n]; ++i)
+            x[ p[n]+i ] = p[n];
+         ++n;
+
+         if (k > 20) {
+            int sz;
+            i = (stb_rand() % n);
+            sz = l[i];
+            stb_block_free(b, p[i], sz);
+            inuse -= sz;
+            p[i] = p[n-1];
+            l[i] = l[n-1];
+            --n;
+
+            freespace = 0;
+            for (i=0; i < b->len; ++i)
+               freespace += b->freelist[i].len;
+            assert(freespace + inuse == 9999);
+         }
+
+
+         ++k;
+
+         // validate
+         if ((k % 50) == 0) {
+            int j;
+            for (j=0; j < n; ++j) {
+               for (i=0; i < l[j]; ++i)
+                  assert(x[ p[j]+i ] == p[j]);
+            }
+         }
+
+         if ((k % 200) == 0) {
+            stb_block_compact_freelist(b);
+         }
+      }
+
+      for (i=0; i < n; ++i)
+         stb_block_free(b, p[i], l[i]);
+
+      stb_block_destroy(b);
+      free(p);
+      free(l);
+      free(x);
+   }
+
+//   blockfile_test();
+
+   mt = stb_lex_matcher();
+   for (i=0; i < 5; ++i)
+      stb_lex_item_wild(mt, wildcards[i], i+1);
+
+   c(1==stb_lex(mt, "this is a foo in the middle",NULL), "stb_matcher_match 1");
+   c(0==stb_lex(mt, "this is a bar in the middle",NULL), "stb_matcher_match 2");
+   c(0==stb_lex(mt, "this is a baz in the middle",NULL), "stb_matcher_match 3");
+   c(2==stb_lex(mt, "this is a bar",NULL), "stb_matcher_match 4");
+   c(0==stb_lex(mt, "this is a baz",NULL), "stb_matcher_match 5");
+   c(3==stb_lex(mt, "baz",NULL), "stb_matcher_match 6");
+   c(4==stb_lex(mt, "1_2_3_4",NULL), "stb_matcher_match 7");
+   c(0==stb_lex(mt, "1  3  3 3 3  2 ",NULL), "stb_matcher_match 8");
+   c(4==stb_lex(mt, "1  3  3 3 2  3 ",NULL), "stb_matcher_match 9");
+   c(5==stb_lex(mt, "C:/sean/prj/old/gdmag/mipmap/hqp/adol-c/CVS/Repository",NULL), "stb_matcher_match 10");
+   stb_matcher_free(mt);
+
+   {
+      #define SSIZE  500000
+      static int arr[SSIZE],arr2[SSIZE];
+      int i,good;
+      for (i=0; i < SSIZE; ++i)
+         arr2[i] = stb_rand();
+      memcpy(arr,arr2,sizeof(arr));
+      printf("stb_define_sort:\n");
+      sort_int(arr, SSIZE);
+      good = 1;
+      for (i=0; i+1 < SSIZE; ++i)
+         if (arr[i] > arr[i+1])
+            good = 0;
+      c(good, "stb_define_sort");
+      printf("qsort:\n");
+      qsort(arr2, SSIZE, sizeof(arr2[0]), stb_intcmp(0));
+      printf("done\n");
+      // check for bugs
+      memset(arr, 0, sizeof(arr[0]) * 1000);
+      sort_int(arr, 1000);
+   }
+
+
+   c(stb_alloc_count_alloc == stb_alloc_count_free, "stb_alloc -2");
+
+   c( stb_is_prime( 2), "stb_is_prime 1");
+   c( stb_is_prime( 3), "stb_is_prime 2");
+   c( stb_is_prime( 5), "stb_is_prime 3");
+   c( stb_is_prime( 7), "stb_is_prime 4");
+   c(!stb_is_prime( 9), "stb_is_prime 5");
+   c( stb_is_prime(11), "stb_is_prime 6");
+   c(!stb_is_prime(25), "stb_is_prime 7");
+   c(!stb_is_prime(27), "stb_is_prime 8");
+   c( stb_is_prime(29), "stb_is_prime 9");
+   c( stb_is_prime(31), "stb_is_prime a");
+   c(!stb_is_prime(33), "stb_is_prime b");
+   c(!stb_is_prime(35), "stb_is_prime c");
+   c(!stb_is_prime(36), "stb_is_prime d");
+
+   for (n=7; n < 64; n += 3) {
+      int i;
+      stb_perfect s;
+      unsigned int *p = malloc(n * sizeof(*p));
+      for (i=0; i < n; ++i)
+         p[i] = i*i;
+      c(stb_perfect_create(&s, p, n), "stb_perfect_hash 1");
+      stb_perfect_destroy(&s);
+      for (i=0; i < n; ++i)
+         p[i] = stb_rand();
+      c(stb_perfect_create(&s, p, n), "stb_perfect_hash 2");
+      stb_perfect_destroy(&s);
+      for (i=0; i < n; ++i)
+         p[i] = (0x80000000 >> stb_log2_ceil(n>>1)) * i;
+      c(stb_perfect_create(&s, p, n), "stb_perfect_hash 2");
+      stb_perfect_destroy(&s);
+      for (i=0; i < n; ++i)
+         p[i] = (int) malloc(1024);
+      c(stb_perfect_create(&s, p, n), "stb_perfect_hash 3");
+      stb_perfect_destroy(&s);
+      for (i=0; i < n; ++i)
+         free((void *) p[i]);
+      free(p);
+   }
+   printf("Maximum attempts required to find perfect hash: %d\n",
+         stb_perfect_hash_max_failures);
+
+   p = "abcdefghijklmnopqrstuvwxyz";
+   c(stb_ischar('c', p), "stb_ischar 1");
+   c(stb_ischar('x', p), "stb_ischar 2");
+   c(!stb_ischar('#', p), "stb_ischar 3");
+   c(!stb_ischar('X', p), "stb_ischar 4");
+   p = "0123456789";
+   c(!stb_ischar('c', p), "stb_ischar 5");
+   c(!stb_ischar('x', p), "stb_ischar 6");
+   c(!stb_ischar('#', p), "stb_ischar 7");
+   c(!stb_ischar('X', p), "stb_ischar 8");
+   p = "#####";
+   c(!stb_ischar('c', p), "stb_ischar a");
+   c(!stb_ischar('x', p), "stb_ischar b");
+   c(stb_ischar('#', p), "stb_ischar c");
+   c(!stb_ischar('X', p), "stb_ischar d");
+   p = "xXyY";
+   c(!stb_ischar('c', p), "stb_ischar e");
+   c(stb_ischar('x', p), "stb_ischar f");
+   c(!stb_ischar('#', p), "stb_ischar g");
+   c(stb_ischar('X', p), "stb_ischar h");
+
+   c(stb_alloc_count_alloc == stb_alloc_count_free, "stb_alloc 1");
+
+   q = stb_wordwrapalloc(15, "How now brown cow. Testinglishously. Okey dokey");
+   // How now brown
+   // cow. Testinglis
+   // hously. Okey
+   // dokey
+   c(stb_arr_len(q) ==  8, "stb_wordwrap 8");
+   c(q[2] == 14 && q[3] == 15, "stb_wordwrap 9");
+   c(q[4] == 29 && q[5] == 12, "stb_wordwrap 10");
+   stb_arr_free(q);
+
+   q = stb_wordwrapalloc(20, "How now brown cow. Testinglishously. Okey dokey");
+   // How now brown cow.
+   // Testinglishously.
+   // Okey dokey
+   c(stb_arr_len(q) ==  6, "stb_wordwrap 1");
+   c(q[0] ==  0 && q[1] == 18, "stb_wordwrap 2");
+   c(q[2] == 19 && q[3] == 17, "stb_wordwrap 3");
+   c(q[4] == 37 && q[5] == 10, "stb_wordwrap 4");
+   stb_arr_free(q);
+
+   q = stb_wordwrapalloc(12, "How now brown cow. Testinglishously. Okey dokey");
+   // How now
+   // brown cow.
+   // Testinglisho
+   // usly. Okey
+   // dokey
+   c(stb_arr_len(q) ==  10, "stb_wordwrap 5");
+   c(q[4] == 19 && q[5] == 12, "stb_wordwrap 6");
+   c(q[6] == 31 && q[3] == 10, "stb_wordwrap 7");
+   stb_arr_free(q);
+
+   //test_script();
+
+   //test_packed_floats();
+
+   c(stb_alloc_count_alloc == stb_alloc_count_free, "stb_alloc 0");
+   if (stb_alloc_count_alloc != stb_alloc_count_free) {
+      printf("%d allocs, %d frees\n", stb_alloc_count_alloc, stb_alloc_count_free);
+   }
+   test_lex();
+
+   mt = stb_regex_matcher(".*foo.*bar.*");
+   c(stb_matcher_match(mt, "foobarx")                == 1, "stb_matcher_match 1");
+   c(stb_matcher_match(mt, "foobar")                 == 1, "stb_matcher_match 2");
+   c(stb_matcher_match(mt, "foo bar")                == 1, "stb_matcher_match 3");
+   c(stb_matcher_match(mt, "fo foo ba ba bar ba")    == 1, "stb_matcher_match 4");
+   c(stb_matcher_match(mt, "fo oo oo ba ba bar foo") == 0, "stb_matcher_match 5");
+   stb_free(mt);
+
+   mt = stb_regex_matcher(".*foo.?bar.*");
+   c(stb_matcher_match(mt, "abfoobarx")                == 1, "stb_matcher_match 6");
+   c(stb_matcher_match(mt, "abfoobar")                 == 1, "stb_matcher_match 7");
+   c(stb_matcher_match(mt, "abfoo bar")                == 1, "stb_matcher_match 8");
+   c(stb_matcher_match(mt, "abfoo  bar")               == 0, "stb_matcher_match 9");
+   c(stb_matcher_match(mt, "abfo foo ba ba bar ba")    == 0, "stb_matcher_match 10");
+   c(stb_matcher_match(mt, "abfo oo oo ba ba bar foo") == 0, "stb_matcher_match 11");
+   stb_free(mt);
+
+   mt = stb_regex_matcher(".*m((foo|bar)*baz)m.*");
+   c(stb_matcher_match(mt, "abfoobarx")                == 0, "stb_matcher_match 12");
+   c(stb_matcher_match(mt, "a mfoofoofoobazm d")       == 1, "stb_matcher_match 13");
+   c(stb_matcher_match(mt, "a mfoobarbazfoom d")       == 0, "stb_matcher_match 14");
+   c(stb_matcher_match(mt, "a mbarbarfoobarbazm d")    == 1, "stb_matcher_match 15");
+   c(stb_matcher_match(mt, "a mfoobarfoo bazm d")      == 0, "stb_matcher_match 16");
+   c(stb_matcher_match(mt, "a mm foobarfoobarfoobar ") == 0, "stb_matcher_match 17");
+   stb_free(mt);
+
+   mt = stb_regex_matcher("f*|z");
+   c(stb_matcher_match(mt, "fz")       == 0, "stb_matcher_match 0a");
+   c(stb_matcher_match(mt, "ff")       == 1, "stb_matcher_match 0b");
+   c(stb_matcher_match(mt, "z")        == 1, "stb_matcher_match 0c");
+   stb_free(mt);
+
+   mt = stb_regex_matcher("m(f|z*)n");
+   c(stb_matcher_match(mt, "mfzn")     == 0, "stb_matcher_match 0d");
+   c(stb_matcher_match(mt, "mffn")     == 0, "stb_matcher_match 0e");
+   c(stb_matcher_match(mt, "mzn")      == 1, "stb_matcher_match 0f");
+   c(stb_matcher_match(mt, "mn")       == 1, "stb_matcher_match 0g");
+   c(stb_matcher_match(mt, "mzfn")     == 0, "stb_matcher_match 0f");
+
+   c(stb_matcher_find(mt, "manmanmannnnnnnmmmmmmmmm       ") == 0, "stb_matcher_find 1");
+   c(stb_matcher_find(mt, "manmanmannnnnnnmmmmmmmmm       ") == 0, "stb_matcher_find 2");
+   c(stb_matcher_find(mt, "manmanmannnnnnnmmmmmmmmmffzzz  ") == 0, "stb_matcher_find 3");
+   c(stb_matcher_find(mt, "manmanmannnnnnnmmmmmmmmmnfzzz  ") == 1, "stb_matcher_find 4");
+   c(stb_matcher_find(mt, "mmmfn aanmannnnnnnmmmmmm fzzz  ") == 1, "stb_matcher_find 5");
+   c(stb_matcher_find(mt, "mmmzzn anmannnnnnnmmmmmm fzzz  ") == 1, "stb_matcher_find 6");
+   c(stb_matcher_find(mt, "mm anmannnnnnnmmmmmm fzmzznzz  ") == 1, "stb_matcher_find 7");
+   c(stb_matcher_find(mt, "mm anmannnnnnnmmmmmm fzmzzfnzz ") == 0, "stb_matcher_find 8");
+   c(stb_matcher_find(mt, "manmfnmannnnnnnmmmmmmmmmffzzz  ") == 1, "stb_matcher_find 9");
+   stb_free(mt);
+
+   mt = stb_regex_matcher(".*m((foo|bar)*|baz)m.*");
+   c(stb_matcher_match(mt, "abfoobarx")                == 0, "stb_matcher_match 18");
+   c(stb_matcher_match(mt, "a mfoofoofoobazm d")       == 0, "stb_matcher_match 19");
+   c(stb_matcher_match(mt, "a mfoobarbazfoom d")       == 0, "stb_matcher_match 20");
+   c(stb_matcher_match(mt, "a mbazm d")                == 1, "stb_matcher_match 21");
+   c(stb_matcher_match(mt, "a mfoobarfoom d")          == 1, "stb_matcher_match 22");
+   c(stb_matcher_match(mt, "a mm foobarfoobarfoobar ") == 1, "stb_matcher_match 23");
+   stb_free(mt);
+
+   mt = stb_regex_matcher("[a-fA-F]..[^]a-zA-Z]");
+   c(stb_matcher_match(mt, "Axx1")                     == 1, "stb_matcher_match 24");
+   c(stb_matcher_match(mt, "Fxx1")                     == 1, "stb_matcher_match 25");
+   c(stb_matcher_match(mt, "Bxx]")                     == 0, "stb_matcher_match 26");
+   c(stb_matcher_match(mt, "Cxxz")                     == 0, "stb_matcher_match 27");
+   c(stb_matcher_match(mt, "gxx[")                     == 0, "stb_matcher_match 28");
+   c(stb_matcher_match(mt, "-xx0")                     == 0, "stb_matcher_match 29");
+   stb_free(mt);
+
+   c(stb_wildmatch("foo*bar", "foobarx")    == 0, "stb_wildmatch 0a");
+   c(stb_wildmatch("foo*bar", "foobar")     == 1, "stb_wildmatch 1a");
+   c(stb_wildmatch("foo*bar", "foo bar")    == 1, "stb_wildmatch 2a");
+   c(stb_wildmatch("foo*bar", "fo foo ba ba bar ba") == 0, "stb_wildmatch 3a");
+   c(stb_wildmatch("foo*bar", "fo oo oo ba ba ar foo") == 0, "stb_wildmatch 4a");
+
+   c(stb_wildmatch("*foo*bar*", "foobar")     == 1, "stb_wildmatch 1b");
+   c(stb_wildmatch("*foo*bar*", "foo bar")    == 1, "stb_wildmatch 2b");
+   c(stb_wildmatch("*foo*bar*", "fo foo ba ba bar ba") == 1, "stb_wildmatch 3b");
+   c(stb_wildmatch("*foo*bar*", "fo oo oo ba ba ar foo") == 0, "stb_wildmatch 4b");
+
+   c(stb_wildmatch("foo*bar*", "foobarx")     == 1, "stb_wildmatch 1c");
+   c(stb_wildmatch("foo*bar*", "foobabar")    == 1, "stb_wildmatch 2c");
+   c(stb_wildmatch("foo*bar*", "fo foo ba ba bar ba") == 0, "stb_wildmatch 3c");
+   c(stb_wildmatch("foo*bar*", "fo oo oo ba ba ar foo") == 0, "stb_wildmatch 4c");
+
+   c(stb_wildmatch("*foo*bar", "foobar")     == 1, "stb_wildmatch 1d");
+   c(stb_wildmatch("*foo*bar", "foo bar")    == 1, "stb_wildmatch 2d");
+   c(stb_wildmatch("*foo*bar", "fo foo ba ba bar ba") == 0, "stb_wildmatch 3d");
+   c(stb_wildmatch("*foo*bar", "fo oo oo ba ba ar foo") == 0, "stb_wildmatch 4d");
+
+   c(stb_wildfind("foo*bar", "xyfoobarx")    == 2, "stb_wildfind 0a");
+   c(stb_wildfind("foo*bar", "aaafoobar")    == 3, "stb_wildfind 1a");
+   c(stb_wildfind("foo*bar", "foo bar")      == 0, "stb_wildfind 2a");
+   c(stb_wildfind("foo*bar", "fo foo ba ba bar ba") == 3, "stb_wildfind 3a");
+   c(stb_wildfind("foo*bar", "fo oo oo ba ba ar foo") == -1, "stb_wildfind 4a");
+
+   c(stb_wildmatch("*foo*;*bar*", "foobar")  == 1, "stb_wildmatch 1e");
+   c(stb_wildmatch("*foo*;*bar*", "afooa")  == 1, "stb_wildmatch 2e");
+   c(stb_wildmatch("*foo*;*bar*", "abara")  == 1, "stb_wildmatch 3e");
+   c(stb_wildmatch("*foo*;*bar*", "abaza")  == 0, "stb_wildmatch 4e");
+   c(stb_wildmatch("*foo*;*bar*", "foboar")  == 0, "stb_wildmatch 5e");
+
+   test_sha1();
+
+   n = sizeof(args_raw)/sizeof(args_raw[0]);
+   memcpy(args, args_raw, sizeof(args_raw));
+   s = stb_getopt(&n, args);
+   c(n >= 1 && !strcmp(args[1], "bar" ), "stb_getopt 1");
+   c(stb_arr_len(s) >= 2 && !strcmp(s[2]   , "r"   ), "stb_getopt 2");
+   stb_getopt_free(s);
+
+   n = sizeof(args_raw)/sizeof(args_raw[0]);
+   memcpy(args, args_raw, sizeof(args_raw));
+   s = stb_getopt_param(&n, args, "f");
+   c(stb_arr_len(s) >= 3 && !strcmp(s[3]   , "fbar"), "stb_getopt 3");
+   stb_getopt_free(s);
+
+   n = sizeof(args_raw)/sizeof(args_raw[0]);
+   memcpy(args, args_raw, sizeof(args_raw));
+   s = stb_getopt_param(&n, args, "x");
+   c(stb_arr_len(s) >= 2 && !strcmp(s[1]   , "xrf" ), "stb_getopt 4");
+   stb_getopt_free(s);
+
+   n = sizeof(args_raw)/sizeof(args_raw[0]);
+   memcpy(args, args_raw, sizeof(args_raw));
+   s = stb_getopt_param(&n, args, "s");
+   c(s == NULL && n == 0     , "stb_getopt 5");
+   stb_getopt_free(s);
+
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3, -1, -1) ==  1, "stb_csample_int 1");
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3,  1, -3) ==  2, "stb_csample_int 2");
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3, 12, -2) ==  5, "stb_csample_int 3");
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3, 15,  1) == 10, "stb_csample_int 4");
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3,  5,  4) == 15, "stb_csample_int 5");
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3,  3,  3) == 14, "stb_csample_int 6");
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3, -2,  5) == 11, "stb_csample_int 7");
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3, -7,  0) ==  1, "stb_csample_int 8");
+   c(*stb_csample_int(sample_test[0], 1, 5, 5, 3,  2,  1) ==  8, "stb_csample_int 9");
+
+   c(!strcmp(stb_splitpath(buf, p1, STB_PATH      ), "foo/bar\\baz/"), "stb_splitpath 1");
+   c(!strcmp(stb_splitpath(buf, p1, STB_FILE      ), "test"), "stb_splitpath 2");
+   c(!strcmp(stb_splitpath(buf, p1, STB_EXT       ), ".xyz"), "stb_splitpath 3");
+   c(!strcmp(stb_splitpath(buf, p1, STB_PATH_FILE ), "foo/bar\\baz/test"), "stb_splitpath 4");
+   c(!strcmp(stb_splitpath(buf, p1, STB_FILE_EXT  ), "test.xyz"), "stb_splitpath 5");
+
+   c(!strcmp(stb_splitpath(buf, p2, STB_PATH      ), "foo/"), "stb_splitpath 6");
+   c(!strcmp(stb_splitpath(buf, p2, STB_FILE      ), ""), "stb_splitpath 7");
+   c(!strcmp(stb_splitpath(buf, p2, STB_EXT       ), ".bar"), "stb_splitpath 8");
+   c(!strcmp(stb_splitpath(buf, p2, STB_PATH_FILE ), "foo/"), "stb_splitpath 9");
+   c(!strcmp(stb_splitpath(buf, p2, STB_FILE_EXT  ), ".bar"), "stb_splitpath 10");
+
+   c(!strcmp(stb_splitpath(buf, p3, STB_PATH      ), "./"), "stb_splitpath 11");
+   c(!strcmp(stb_splitpath(buf, p3, STB_FILE      ), "foo"), "stb_splitpath 12");
+   c(!strcmp(stb_splitpath(buf, p3, STB_EXT       ), ".bar"), "stb_splitpath 13");
+   c(!strcmp(stb_splitpath(buf, p3, STB_PATH_FILE ), "foo"), "stb_splitpath 14");
+
+   c(!strcmp(stb_splitpath(buf, p4, STB_PATH      ), "foo/"), "stb_splitpath 16");
+   c(!strcmp(stb_splitpath(buf, p4, STB_FILE      ), "bar"), "stb_splitpath 17");
+   c(!strcmp(stb_splitpath(buf, p4, STB_EXT       ), ""), "stb_splitpath 18");
+   c(!strcmp(stb_splitpath(buf, p4, STB_PATH_FILE ), "foo/bar"), "stb_splitpath 19");
+   c(!strcmp(stb_splitpath(buf, p4, STB_FILE_EXT  ), "bar"), "stb_splitpath 20");
+
+   c(!strcmp(p=stb_dupreplace("testfootffooo foo fox", "foo", "brap"), "testbraptfbrapo brap fox"), "stb_dupreplace 1"); free(p);
+   c(!strcmp(p=stb_dupreplace("testfootffooo foo fox", "foo", ""    ), "testtfo  fox"            ), "stb_dupreplace 2"); free(p);
+   c(!strcmp(p=stb_dupreplace("abacab", "a", "aba"),                   "abababacabab"            ), "stb_dupreplace 3"); free(p);
+
+
+   m = stb_mml_parse("<a><b><c>x</c><d>y</d></b><e>&lt;&amp;f&gt;</e></a>");
+   c(m != NULL, "stb_mml_parse 1");
+   if (m) {
+      c(!strcmp(m->child[0]->child[0]->child[1]->tag, "d"), "stb_mml_parse 2");
+      c(!strcmp(m->child[0]->child[1]->leaf_data, "<&f>"), "stb_mml_parse 3");
+   }
+   if (m)
+      stb_mml_free(m);
+   c(stb_alloc_count_alloc == stb_alloc_count_free, "stb_alloc 1");
+   if (stb_alloc_count_alloc != stb_alloc_count_free) {
+      printf("%d allocs, %d frees\n", stb_alloc_count_alloc, stb_alloc_count_free);
+   }
+
+   c(stb_linear_remap(3.0f,0,8,1,2) == 1.375, "stb_linear_remap()");
+
+   c(stb_bitreverse(0x1248fec8) == 0x137f1248, "stb_bitreverse() 1");
+   c(stb_bitreverse8(0x4e) == 0x72, "stb_bitreverse8() 1");
+   c(stb_bitreverse8(0x31) == 0x8c, "stb_bitreverse8() 2");
+   for (n=1; n < 255; ++n) {
+      unsigned int m = stb_bitreverse8((uint8) n);
+      c(stb_bitreverse8((uint8) m) == (unsigned int) n, "stb_bitreverse8() 3");
+   }
+
+   for (n=2; n <= 31; ++n) {
+      c(stb_is_pow2   ((1 << n)  ) == 1  , "stb_is_pow2() 1");
+      c(stb_is_pow2   ((1 << n)+1) == 0  , "stb_is_pow2() 2");
+      c(stb_is_pow2   ((1 << n)-1) == 0  , "stb_is_pow2() 3");
+
+      c(stb_log2_floor((1 << n)  ) == n  , "stb_log2_floor() 1");
+      c(stb_log2_floor((1 << n)+1) == n  , "stb_log2_floor() 2");
+      c(stb_log2_floor((1 << n)-1) == n-1, "stb_log2_floor() 3");
+
+      c(stb_log2_ceil ((1 << n)  ) == n  , "stb_log2_ceil() 1");
+      c(stb_log2_ceil ((1 << n)+1) == n+1, "stb_log2_ceil() 2");
+      c(stb_log2_ceil ((1 << n)-1) == n  , "stb_log2_ceil() 3");
+
+      c(stb_bitreverse(1 << n) == 1U << (31-n), "stb_bitreverse() 2");
+   }
+
+   c(stb_log2_floor(0) == -1, "stb_log2_floor() 4");
+   c(stb_log2_ceil (0) == -1, "stb_log2_ceil () 4");
+
+   c(stb_log2_floor(-1) == 31, "stb_log2_floor() 5");
+   c(stb_log2_ceil (-1) == 32, "stb_log2_ceil () 5");
+
+   c(stb_bitcount(0xffffffff) == 32, "stb_bitcount() 1");
+   c(stb_bitcount(0xaaaaaaaa) == 16, "stb_bitcount() 2");
+   c(stb_bitcount(0x55555555) == 16, "stb_bitcount() 3");
+   c(stb_bitcount(0x00000000) ==  0, "stb_bitcount() 4");
+
+   c(stb_lowbit8(0xf0) == 4, "stb_lowbit8 1");
+   c(stb_lowbit8(0x10) == 4, "stb_lowbit8 2");
+   c(stb_lowbit8(0xf3) == 0, "stb_lowbit8 3");
+   c(stb_lowbit8(0xf8) == 3, "stb_lowbit8 4");
+   c(stb_lowbit8(0x60) == 5, "stb_lowbit8 5");
+
+   for (n=0; n < sizeof(buf); ++n)
+      buf[n] = 0;
+
+   for (n = 0; n < 200000; ++n) {
+      unsigned int k = stb_rand();
+      int i,z=0;
+      for (i=0; i < 32; ++i)
+         if (k & (1 << i)) ++z;
+      c(stb_bitcount(k) == z, "stb_bitcount() 5");
+
+      buf[k >> 24] = 1;
+
+      if (k != 0) {
+         if (stb_is_pow2(k)) {
+            c(stb_log2_floor(k) == stb_log2_ceil(k), "stb_is_pow2() 1");
+            c(k == 1U << stb_log2_floor(k), "stb_is_pow2() 2");
+         } else {
+            c(stb_log2_floor(k) == stb_log2_ceil(k)-1, "stb_is_pow2() 3");
+         }
+      }
+
+      c(stb_bitreverse(stb_bitreverse(n)) == (uint32) n, "stb_bitreverse() 3");
+   }
+
+   // make sure reasonable coverage from stb_rand()
+   for (n=0; n < sizeof(buf); ++n)
+      c(buf[n] != 0, "stb_rand()");
+
+   for (n=0; n < sizeof(buf); ++n)
+      buf[n] = 0;
+
+   for (n=0; n < 60000; ++n) {
+      float z = (float) stb_frand();
+      int n = (int) (z * sizeof(buf));
+      c(z >= 0 && z < 1, "stb_frand() 1");
+      c(n >= 0 && n < sizeof(buf), "stb_frand() 2");
+      buf[n] = 1;
+   }
+
+   // make sure reasonable coverage from stb_frand(),
+   // e.g. that the range remap isn't incorrect
+   for (n=0; n < sizeof(buf); ++n)
+      c(buf[n] != 0, "stb_frand()");
+         
+
+   // stb_arr
+   {
+      short *s = NULL;
+
+      c(sum(s) == 0, "stb_arr 1");
+
+      stb_arr_add(s); s[0] = 3;
+      stb_arr_push(s,7);
+
+      c( stb_arr_valid(s,1), "stb_arr 2");
+      c(!stb_arr_valid(s,2), "stb_arr 3");
+
+      // force a realloc
+      stb_arr_push(s,0);
+      stb_arr_push(s,0);
+      stb_arr_push(s,0);
+      stb_arr_push(s,0);
+
+      c(sum(s) == 10, "stb_arr 4");
+      stb_arr_push(s,0);
+      s[0] = 1; s[1] = 5; s[2] = 20;
+      c(sum(s) == 26, "stb_arr 5");
+      stb_arr_setlen(s,2);
+      c(sum(s) == 6, "stb_arr 6");
+      stb_arr_setlen(s,1);
+      c(sum(s) == 1, "stb_arr 7");
+      stb_arr_setlen(s,0);
+      c(sum(s) == 0, "stb_arr 8");
+
+      stb_arr_push(s,3);
+      stb_arr_push(s,4);
+      stb_arr_push(s,5);
+      stb_arr_push(s,6);
+      stb_arr_push(s,7);
+      stb_arr_deleten(s,1,3);
+      c(stb_arr_len(s)==2 && sum(s) == 10, "stb_arr_9");
+
+      stb_arr_push(s,2);
+      // 3 7 2
+      stb_arr_insertn(s,2,2);
+      // 3 7 x x 2
+      s[2] = 5;
+      s[3] = 6;
+      c(s[0]==3 && s[1] == 7 && s[2] == 5 && s[3] == 6 && s[4] == 2, "stb_arr 10");
+      stb_arr_free(s);
+   }
+
+   #if 1
+   f= stb_fopen("data/stb.test", "wb");
+   fwrite(buffer, 1, sizeof(buffer)-1, f);
+   stb_fclose(f, stb_keep_yes);
+   #ifndef WIN32
+   sleep(1);  // andLinux has some synchronization problem here
+   #endif
+   #else
+   f= fopen("data/stb.test", "wb");
+   fwrite(buffer, 1, sizeof(buffer)-1, f);
+   fclose(f);
+   #endif
+   if (!stb_fexists("data/stb.test")) {
+      fprintf(stderr, "Error: couldn't open file just written, or stb_fexists() is broken.\n");
+   }
+
+   f = fopen("data/stb.test", "rb");
+   // f = NULL; // test stb_fatal()
+   if (!f) { stb_fatal("Error: couldn't open file just written\n"); }
+   else {
+      char temp[4];
+      int len1 = stb_filelen(f), len2;
+      int n1,n2;
+      if (fread(temp,1,4,f) == 0) {
+         int n = ferror(f);
+         if (n) { stb_fatal("Error reading from stream: %d", n); }
+         if (feof(f)) stb_fatal("Weird, read 0 bytes and hit eof");
+         stb_fatal("Read 0, but neither feof nor ferror is true");
+      }
+      fclose(f);
+      p = stb_file("data/stb.test", &len2);
+      if (p == NULL) stb_fatal("Error: stb_file() failed");
+      c(len1 == sizeof(buffer)-1, "stb_filelen()");
+      c(len2 == sizeof(buffer)-1, "stb_file():n");
+      c(memcmp(p, buffer, sizeof(buffer)-1) == 0, "stb_file()");
+      c(strcmp(p, buffer)==0, "stb_file() terminated");
+      free(p);
+
+      s = stb_stringfile("data/stb.test", &n1);
+      c(n1 == 3, "stb_stringfile():n");
+      n2 = 0;
+      while (s[n2]) ++n2;
+      c(n1 == n2, "stb_stringfile():n length matches the non-NULL strings");
+      if (n2 == 3) {
+         c(strcmp(s[0],str1)==0, "stb_stringfile()[0]");
+         c(strcmp(s[1],str2)==0, "stb_stringfile()[1]");
+         c(strcmp(s[2],str3)==0, "stb_stringfile()[2] (no terminating newlines)");
+      }
+      free(s);
+
+      f = fopen("data/stb.test", "rb");
+      stb_fgets(buf, sizeof(buf), f);
+      //c(strcmp(buf, str1)==0, "stb_fgets()");
+      p = stb_fgets_malloc(f);
+      n1 = strlen(p);
+      n2 = strlen(str2);
+      c(strcmp(p, str2)==0, "stb_fgets_malloc()");
+      free(p);
+      stb_fgets(buf, sizeof(buf), f);
+      c(strcmp(buf, str3)==0, "stb_fgets()3");
+   }
+
+   c( stb_prefix("foobar", "foo"), "stb_prefix() 1");
+   c(!stb_prefix("foo", "foobar"), "stb_prefix() 2");
+   c( stb_prefix("foob", "foob" ), "stb_prefix() 3");
+
+   stb_strncpy(buf, "foobar", 6);  c(strcmp(buf,"fooba" )==0, "stb_strncpy() 1");
+   stb_strncpy(buf, "foobar", 8);  c(strcmp(buf,"foobar")==0, "stb_strncpy() 2");
+
+   c(!strcmp(p=stb_duplower("FooBar"), "foobar"), "stb_duplower()"); free(p);
+   strcpy(buf, "FooBar");
+   stb_tolower(buf);
+   c(!strcmp(buf, "foobar"), "stb_tolower()");
+
+   p = stb_strtok(buf, "foo=ba*r", "#=*");
+   c(!strcmp(buf, "foo" ), "stb_strtok() 1");
+   c(!strcmp(p  , "ba*r"), "stb_strtok() 2");
+   p = stb_strtok(buf, "foobar", "#=*");
+   c(*p == 0, "stb_strtok() 3");
+
+   c(!strcmp(stb_skipwhite(" \t\n foo"), "foo"), "stb_skipwhite()");
+
+   s = stb_tokens("foo == ba*r", "#=*", NULL);
+   c(!strcmp(s[0], "foo "), "stb_tokens() 1");
+   c(!strcmp(s[1], " ba"),  "stb_tokens() 2");
+   c(!strcmp(s[2], "r"),    "stb_tokens() 3");
+   c(s[3] == 0,             "stb_tokens() 4");
+   free(s);
+
+   s = stb_tokens_allowempty("foo == ba*r", "#=*", NULL);
+   c(!strcmp(s[0], "foo "), "stb_tokens_allowempty() 1");
+   c(!strcmp(s[1], ""    ), "stb_tokens_allowempty() 2");
+   c(!strcmp(s[2], " ba"),  "stb_tokens_allowempty() 3");
+   c(!strcmp(s[3], "r"),    "stb_tokens_allowempty() 4");
+   c(s[4] == 0,             "stb_tokens_allowempty() 5");
+   free(s);
+
+   s = stb_tokens_stripwhite("foo == ba*r", "#=*", NULL);
+   c(!strcmp(s[0], "foo"),  "stb_tokens_stripwhite() 1");
+   c(!strcmp(s[1], ""   ),  "stb_tokens_stripwhite() 2");
+   c(!strcmp(s[2], "ba"),   "stb_tokens_stripwhite() 3");
+   c(!strcmp(s[3], "r"),    "stb_tokens_stripwhite() 4");
+   c(s[4] == 0,             "stb_tokens_stripwhite() 5");
+   free(s);
+
+   s = stb_tokens_quoted("foo =\"=\" ba*\"\"r \" foo\" bah    ", "#=*", NULL);
+   c(!strcmp(s[0], "foo"),  "stb_tokens_quoted() 1");
+   c(!strcmp(s[1], "= ba"), "stb_tokens_quoted() 2");
+   c(!strcmp(s[2], "\"r  foo bah"),  "stb_tokens_quoted() 3");
+   c(s[3] == 0,             "stb_tokens_quoted() 4");
+   free(s);
+
+
+   p = stb_file("stb.h", &len2);
+   if (p) {
+      uint32 z = stb_adler32_old(1, p, len2);
+      uint32 x = stb_adler32    (1, p, len2);
+      c(z == x, "stb_adler32() 1");
+      memset(p,0xff,len2);
+      z = stb_adler32_old((65520<<16) + 65520, p, len2);
+      x = stb_adler32    ((65520<<16) + 65520, p, len2);
+      c(z == x, "stb_adler32() 2");
+      free(p);
+   }
+
+   //   stb_hheap
+   {
+      #define HHEAP_COUNT  100000
+      void **p = malloc(sizeof(*p) * HHEAP_COUNT);
+      int i, j;
+      #if 0
+      stb_hheap *h2, *h = stb_newhheap(sizeof(struct1),0);
+
+      for (i=0; i < HHEAP_COUNT; ++i)
+         p[i] = stb_halloc(h);
+      stb_shuffle(p, HHEAP_COUNT, sizeof(*p), stb_rand());
+      for (i=0; i < HHEAP_COUNT; ++i)
+         stb_hfree(p[i]);
+
+      c(h->num_alloc == 0, "stb_hheap 1");
+      stb_delhheap(h);
+
+      h = stb_newhheap(sizeof(struct1),0);
+      h2 = stb_newhheap(sizeof(struct2),8);
+
+      for (i=0; i < HHEAP_COUNT; ++i) {
+         if (i & 1)
+            p[i] = stb_halloc(h);
+         else {
+            p[i] = stb_halloc(h2);
+            c((((int) p[i]) & 4) == 0, "stb_hheap 2");
+         }
+      }
+
+      stb_shuffle(p, HHEAP_COUNT, sizeof(*p), stb_rand());
+      for (i=0; i < HHEAP_COUNT; ++i)
+         stb_hfree(p[i]);
+
+      c(h->num_alloc == 0, "stb_hheap 3");
+      c(h2->num_alloc == 0, "stb_hheap 4");
+
+      stb_delhheap(h);
+      stb_delhheap(h2);
+      #else
+      for (i=0; i < HHEAP_COUNT; ++i)
+         p[i] = malloc(32);
+      stb_shuffle(p, HHEAP_COUNT, sizeof(*p), stb_rand());
+      for (i=0; i < HHEAP_COUNT; ++i)
+         free(p[i]);
+      #endif
+
+      // now use the same array of pointers to do pointer set operations
+      for (j=100; j < HHEAP_COUNT; j += 25000) {
+         stb_ps *ps = NULL;
+         for (i=0; i < j; ++i)
+            ps = stb_ps_add(ps, p[i]);
+
+         for (i=0; i < HHEAP_COUNT; ++i)
+            c(stb_ps_find(ps, p[i]) == (i < j), "stb_ps 1");
+         c(stb_ps_count(ps) == j, "stb_ps 1b");
+
+         for (i=j; i < HHEAP_COUNT; ++i)
+            ps = stb_ps_add(ps, p[i]);
+
+         for (i=0; i < j; ++i)
+            ps = stb_ps_remove(ps, p[i]);
+
+         for (i=0; i < HHEAP_COUNT; ++i)
+            c(stb_ps_find(ps, p[i]) == !(i < j), "stb_ps 2");
+
+         stb_ps_delete(ps);
+      }
+
+      #define HHEAP_COUNT2   100
+      // now use the same array of pointers to do pointer set operations
+      for (j=1; j < 40; ++j) {
+         stb_ps *ps = NULL;
+         for (i=0; i < j; ++i)
+            ps = stb_ps_add(ps, p[i]);
+
+         for (i=0; i < HHEAP_COUNT2; ++i)
+            c(stb_ps_find(ps, p[i]) == (i < j), "stb_ps 3");
+         c(stb_ps_count(ps) == j, "stb_ps 3b");
+
+         for (i=j; i < HHEAP_COUNT2; ++i)
+            ps = stb_ps_add(ps, p[i]);
+
+         for (i=0; i < j; ++i)
+            ps = stb_ps_remove(ps, p[i]);
+
+         for (i=0; i < HHEAP_COUNT2; ++i)
+            c(stb_ps_find(ps, p[i]) == !(i < j), "stb_ps 4");
+
+         stb_ps_delete(ps);
+      }
+
+      free(p);
+   }
+
+
+   n = test_compression(tc, sizeof(tc));
+   c(n >= 0, "stb_compress()/stb_decompress() 1");
+
+   p = stb_file("stb.h", &len2);
+   if (p) {
+      FILE *f = fopen("data/stb_h.z", "wb");
+      if (stb_compress_stream_start(f)) {
+         int i;
+         void *q;
+         int len3;
+
+         for (i=0; i < len2; ) {
+            int n = stb_rand() % 10;
+            if (n <= 6) n = 1 + stb_rand()%16;
+            else if (n <= 8) n = 20 + stb_rand() % 1000;
+            else n = 15000;
+            if (i + n > len2) n = len2 - i;
+            stb_write(p + i, n);
+            i += n;
+         }
+         stb_compress_stream_end(1);
+
+         q = stb_decompress_fromfile("data/stb_h.z", &len3);
+         c(len3 == len2, "stb_compress_stream 2");
+         if (len2 == len3)
+            c(!memcmp(p,q,len2), "stb_compress_stream 3");
+         if (q) free(q);
+      } else {
+         c(0, "stb_compress_stream 1");
+      }
+
+      free(p);
+      stb_compress_window(65536*4);
+   }
+
+   p = stb_file("stb.h", &len2);
+   if (p) {
+      n = test_compression(p, len2);
+      c(n >= 0, "stb_compress()/stb_decompress() 2");
+      #if 0
+      n = test_en_compression(p, len2);
+      c(n >= 0, "stb_en_compress()/stb_en_decompress() 2");
+      #endif
+      free(p);
+   } else {
+      fprintf(stderr, "No stb.h to compression test.\n");
+   }
+
+   p = stb_file("data/test.bmp", &len2);
+   if (p) {
+      n = test_compression(p, len2);
+      c(n == 106141, "stb_compress()/stb_decompress() 4");
+      #if 0
+      n = test_en_compression(p, len2);
+      c(n >= 0, "stb_en_compress()/stb_en_decompress() 4");
+      #endif
+      free(p);
+   }
+
+   // the hardcoded compressed lengths being verified _could_
+   // change if you changed the compresser parameters; but pure
+   // performance optimizations shouldn't change them
+   p = stb_file("data/cantrbry.zip", &len2);
+   if (p) {
+      n = test_compression(p, len2);
+      c(n == 642787, "stb_compress()/stb_decompress() 3");
+      #if 0
+      n = test_en_compression(p, len2);
+      c(n >= 0, "stb_en_compress()/stb_en_decompress() 3");
+      #endif
+      free(p);
+   }
+
+   p = stb_file("data/bible.txt", &len2);
+   if (p) {
+      n = test_compression(p, len2);
+      c(n == 2022520, "stb_compress()/stb_decompress() 4");
+      #if 0
+      n = test_en_compression(p, len2);
+      c(n >= 0, "stb_en_compress()/stb_en_decompress() 4");
+      #endif
+      free(p);
+   }
+
+   {
+      int len = 1 << 25, o=0; // 32MB
+      char *buffer = malloc(len);
+      int i;
+      for (i=0; i < 8192; ++i)
+         buffer[o++] = (char) stb_rand();
+      for (i=0; i < (1 << 15); ++i)
+         buffer[o++] = 1;
+      for (i=0; i < 64; ++i)
+         buffer[o++] = buffer[i];
+      for (i=0; i < (1 << 21); ++i)
+         buffer[o++] = 2;
+      for (i=0; i < 64; ++i)
+         buffer[o++] = buffer[i];
+      for (i=0; i < (1 << 21); ++i)
+         buffer[o++] = 3;
+      for (i=0; i < 8192; ++i)
+         buffer[o++] = buffer[i];
+      for (i=0; i < (1 << 21); ++i)
+         buffer[o++] = 4;
+      assert(o < len);
+      stb_compress_window(1 << 24);
+      i = test_compression(buffer, len);
+      c(n >= 0, "stb_compress() 6");
+      free(buffer);
+   }
+
+   #ifdef STB_THREADS
+   stb_thread_cleanup();
+   #endif
+   stb_ischar(0,NULL);
+   stb_wrapper_listall(dumpfunc);
+   printf("Memory still in use: %d allocations of %d bytes.\n", alloc_num, alloc_size);
+
+   // force some memory checking
+   for (n=1; n < 20; ++n)
+      malloc(1 << n);
+
+   stb_("Finished stb.c with %d errors.", count);
+
+   return 0;
+}
+
+
+
+
+
+// NIST test vectors
+
+struct
+{
+   int length;
+   char *message;
+   char *digest;
+} sha1_tests[] =
+{
+   24,
+"616263",
+"a9993e364706816aba3e25717850c26c9cd0d89d",
+
+   1304,
+"ec29561244ede706b6eb30a1c371d74450a105c3f9735f7fa9fe38cf67f304a5736a106e"
+"92e17139a6813b1c81a4f3d3fb9546ab4296fa9f722826c066869edacd73b25480351858"
+"13e22634a9da44000d95a281ff9f264ecce0a931222162d021cca28db5f3c2aa24945ab1"
+"e31cb413ae29810fd794cad5dfaf29ec43cb38d198fe4ae1da2359780221405bd6712a53"
+"05da4b1b737fce7cd21c0eb7728d08235a9011",
+"970111c4e77bcc88cc20459c02b69b4aa8f58217",
+
+   2096,
+"5fc2c3f6a7e79dc94be526e5166a238899d54927ce470018fbfd668fd9dd97cbf64e2c91"
+"584d01da63be3cc9fdff8adfefc3ac728e1e335b9cdc87f069172e323d094b47fa1e652a"
+"fe4d6aa147a9f46fda33cacb65f3aa12234746b9007a8c85fe982afed7815221e43dba55"
+"3d8fe8a022cdac1b99eeeea359e5a9d2e72e382dffa6d19f359f4f27dc3434cd27daeeda"
+"8e38594873398678065fbb23665aba9309d946135da0e4a4afdadff14db18e85e71dd93c"
+"3bf9faf7f25c8194c4269b1ee3d9934097ab990025d9c3aaf63d5109f52335dd3959d38a"
+"e485050e4bbb6235574fc0102be8f7a306d6e8de6ba6becf80f37415b57f9898a5824e77"
+"414197422be3d36a6080",
+   "0423dc76a8791107d14e13f5265b343f24cc0f19",
+
+   2888,
+"0f865f46a8f3aed2da18482aa09a8f390dc9da07d51d1bd10fe0bf5f3928d5927d08733d"
+"32075535a6d1c8ac1b2dc6ba0f2f633dc1af68e3f0fa3d85e6c60cb7b56c239dc1519a00"
+"7ea536a07b518ecca02a6c31b46b76f021620ef3fc6976804018380e5ab9c558ebfc5cb1"
+"c9ed2d974722bf8ab6398f1f2b82fa5083f85c16a5767a3a07271d67743f00850ce8ec42"
+"8c7f22f1cf01f99895c0c844845b06a06cecb0c6cf83eb55a1d4ebc44c2c13f6f7aa5e0e"
+"08abfd84e7864279057abc471ee4a45dbbb5774afa24e51791a0eada11093b88681fe30b"
+"aa3b2e94113dc63342c51ca5d1a6096d0897b626e42cb91761058008f746f35465465540"
+"ad8c6b8b60f7e1461b3ce9e6529625984cb8c7d46f07f735be067588a0117f23e34ff578"
+"00e2bbe9a1605fde6087fb15d22c5d3ac47566b8c448b0cee40373e5ba6eaa21abee7136"
+"6afbb27dbbd300477d70c371e7b8963812f5ed4fb784fb2f3bd1d3afe883cdd47ef32bea"
+"ea",
+   "6692a71d73e00f27df976bc56df4970650d90e45",
+
+   3680,
+"4893f1c763625f2c6ce53aacf28026f14b3cd8687e1a1d3b60a81e80fcd1e2b038f9145a"
+"b64a0718f948f7c3c9ac92e3d86fb669a5257da1a18c776291653688338210a3242120f1"
+"01788e8acc9110db9258b1554bf3d26602516ea93606a25a7f566c0c758fb39ecd9d876b"
+"c5d8abc1c3205095382c2474cb1f8bbdb45c2c0e659cb0fc703ec607a5de6bcc7a28687d"
+"b1ee1c8f34797bb2441d5706d210df8c2d7d65dbded36414d063c117b52a51f7a4eb9cac"
+"0782e008b47459ed5acac0bc1f20121087f992ad985511b33c866d18e63f585478ee5a5e"
+"654b19d81231d98683ae3f0533565aba43dce408d7e3c4c6be11d8f05165f29c9dcb2030"
+"c4ee31d3a04e7421aa92c3231a1fc07e50e95fea7389a5e65891afaba51cf55e36a9d089"
+"bf293accb356d5d06547307d6e41456d4ed146a056179971c56521c83109bf922866186e"
+"184a99a96c7bb96df8937e35970e438412a2b8d744cf2ad87cb605d4232e976f9f151697"
+"76e4e5b6b786132c966b25fc56d815c56c819af5e159aa39f8a93d38115f5580cda93bc0"
+"73c30b39920e726fe861b72483a3f886269ab7a8eefe952f35d25c4eb7f443f4f3f26e43"
+"d51fb54591e6a6dad25fcdf5142033084e5624bdd51435e77dea86b8",
+   "dc5859dd5163c4354d5d577b855fa98e37f04384",
+
+   4472,
+"cf494c18a4e17bf03910631471bca5ba7edea8b9a63381e3463517961749848eb03abefd"
+"4ce676dece3740860255f57c261a558aa9c7f11432f549a9e4ce31d8e17c79450ce2ccfc"
+"148ad904aedfb138219d7052088520495355dadd90f72e6f69f9c6176d3d45f113f275b7"
+"fbc2a295784d41384cd7d629b23d1459a22e45fd5097ec9bf65fa965d3555ec77367903c"
+"32141065fc24da5c56963d46a2da3c279e4035fb2fb1c0025d9dda5b9e3443d457d92401"
+"a0d3f58b48469ecb1862dc975cdbe75ca099526db8b0329b03928206f084c633c04eef5e"
+"8e377f118d30edf592504be9d2802651ec78aeb02aea167a03fc3e23e5fc907c324f283f"
+"89ab37e84687a9c74ccf055402db95c29ba2c8d79b2bd4fa96459f8e3b78e07e923b8119"
+"8267492196ecb71e01c331f8df245ec5bdf8d0e05c91e63bb299f0f6324895304dda721d"
+"39410458f117c87b7dd6a0ee734b79fcbe482b2c9e9aa0cef03a39d4b0c86de3bc34b4aa"
+"dabfa373fd2258f7c40c187744d237080762382f547a36adb117839ca72f8ebbc5a20a07"
+"e86f4c8bb923f5787698d278f6db0040e76e54645bb0f97083995b34b9aa445fc4244550"
+"58795828dd00c32471ec402a307f5aa1b37b1a86d6dae3bcbfbe9ba41cab0beeabf489af"
+"0073d4b3837d3f14b815120bc3602d072b5aeefcdec655fe756b660eba7dcf34675acbce"
+"317746270599424b9248791a0780449c1eabbb9459cc1e588bfd74df9b1b711c85c09d8a"
+"a171b309281947e8f4b6ac438753158f4f36fa",
+   "4c17926feb6e87f5bca7890d8a5cde744f231dab",
+
+   5264,
+"8236153781bd2f1b81ffe0def1beb46f5a70191142926651503f1b3bb1016acdb9e7f7ac"
+"ced8dd168226f118ff664a01a8800116fd023587bfba52a2558393476f5fc69ce9c65001"
+"f23e70476d2cc81c97ea19caeb194e224339bcb23f77a83feac5096f9b3090c51a6ee6d2"
+"04b735aa71d7e996d380b80822e4dfd43683af9c7442498cacbea64842dfda238cb09992"
+"7c6efae07fdf7b23a4e4456e0152b24853fe0d5de4179974b2b9d4a1cdbefcbc01d8d311"
+"b5dda059136176ea698ab82acf20dd490be47130b1235cb48f8a6710473cfc923e222d94"
+"b582f9ae36d4ca2a32d141b8e8cc36638845fbc499bce17698c3fecae2572dbbd4705524"
+"30d7ef30c238c2124478f1f780483839b4fb73d63a9460206824a5b6b65315b21e3c2f24"
+"c97ee7c0e78faad3df549c7ca8ef241876d9aafe9a309f6da352bec2caaa92ee8dca3928"
+"99ba67dfed90aef33d41fc2494b765cb3e2422c8e595dabbfaca217757453fb322a13203"
+"f425f6073a9903e2dc5818ee1da737afc345f0057744e3a56e1681c949eb12273a3bfc20"
+"699e423b96e44bd1ff62e50a848a890809bfe1611c6787d3d741103308f849a790f9c015"
+"098286dbacfc34c1718b2c2b77e32194a75dda37954a320fa68764027852855a7e5b5274"
+"eb1e2cbcd27161d98b59ad245822015f48af82a45c0ed59be94f9af03d9736048570d6e3"
+"ef63b1770bc98dfb77de84b1bb1708d872b625d9ab9b06c18e5dbbf34399391f0f8aa26e"
+"c0dac7ff4cb8ec97b52bcb942fa6db2385dcd1b3b9d567aaeb425d567b0ebe267235651a"
+"1ed9bf78fd93d3c1dd077fe340bb04b00529c58f45124b717c168d07e9826e33376988bc"
+"5cf62845c2009980a4dfa69fbc7e5a0b1bb20a5958ca967aec68eb31dd8fccca9afcd30a"
+"26bab26279f1bf6724ff",
+   "11863b483809ef88413ca9b0084ac4a5390640af",
+
+   6056,
+"31ec3c3636618c7141441294fde7e72366a407fa7ec6a64a41a7c8dfda150ca417fac868"
+"1b3c5be253e3bff3ab7a5e2c01b72790d95ee09b5362be835b4d33bd20e307c3c702aa15"
+"60cdc97d190a1f98b1c78e9230446e31d60d25155167f73e33ed20cea27b2010514b57ba"
+"b05ed16f601e6388ea41f714b0f0241d2429022e37623c11156f66dd0fa59131d8401dba"
+"f502cffb6f1d234dcb53e4243b5cf9951688821586a524848123a06afa76ab8058bcfa72"
+"27a09ce30d7e8cb100c8877bb7a81b615ee6010b8e0daced7cc922c971940b757a9107de"
+"60b8454dda3452e902092e7e06faa57c20aadc43c8012b9d28d12a8cd0ba0f47ab4b377f"
+"316902e6dff5e4f2e4a9b9de1e4359f344e66d0565bd814091e15a25d67d89cf6e30407b"
+"36b2654762bbe53a6f204b855a3f9108109e351825cf9080c89764c5f74fb4afef89d804"
+"e7f7d097fd89d98171d63eaf11bd719df44c5a606be0efea358e058af2c265b2da2623fd"
+"afc62b70f0711d0150625b55672060cea6a253c590b7db1427a536d8a51085756d1e6ada"
+"41d9d506b5d51bcae41249d16123b7df7190e056777a70feaf7d9f051fdbbe45cbd60fc6"
+"295dda84d4ebbd7284ad44be3ee3ba57c8883ead603519b8ad434e3bf630734a9243c00a"
+"a07366b8f88621ec6176111f0418c66b20ff9a93009f43432aaea899dad0f4e3ae72e9ab"
+"a3f678f140118eb7117230c357a5caa0fe36c4e6cf1957bbe7499f9a68b0f1536e476e53"
+"457ed826d9dea53a6ded52e69052faaa4d3927b9a3f9e8b435f424b941bf2d9cd6849874"
+"42a44d5acaa0da6d9f390d1a0dd6c19af427f8bb7c082ae405a8dd535dea76aa360b4faa"
+"d786093e113424bb75b8cc66c41af637a7b2acdca048a501417919cf9c5cd3b2fa668860"
+"d08b6717eea6f125fa1b0bae1dbb52aafce8ae2deaf92aeb5be003fb9c09fedbc286ffb5"
+"e16ad8e07e725faa46ebc35500cf205fc03250075ddc050c263814b8d16d141db4ca289f"
+"386719b28a09a8e5934722202beb3429899b016dfeb972fee487cdd8d18f8a681042624f"
+"51",
+   "f43937922444421042f76756fbed0338b354516f",
+
+   6848,
+"21b9a9686ec200456c414f2e6963e2d59e8b57e654eced3d4b57fe565b51c9045c697566"
+"44c953178f0a64a6e44d1b46f58763c6a71ce4c373b0821c0b3927a64159c32125ec916b"
+"6edd9bf41c3d80725b9675d6a97c8a7e3b662fac9dbcf6379a319a805b5341a8d360fe00"
+"5a5c9ac1976094fea43566d66d220aee5901bd1f2d98036b2d27eb36843e94b2e5d1f09c"
+"738ec826de6e0034cf8b1dca873104c5c33704cae290177d491d65f307c50a69b5c81936"
+"a050e1fe2b4a6f296e73549323b6a885c3b54ee5eca67aa90660719126b590163203909e"
+"470608f157f033f017bcf48518bf17d63380dabe2bc9ac7d8efe34aedcae957aeb68f10c"
+"8ad02c4465f1f2b029d5fbb8e8538d18be294394b54b0ee6e67a79fce11731604f3ac4f8"
+"d6ffa9ef3d2081f3d1c99ca107a7bf3d624324a7978ec38af0bcd0d7ee568572328b212b"
+"9dc831efb7880e3f4d6ca7e25f8e80d73913fb8edfffd758ae4df61b4140634a92f49314"
+"6138ebdcdaa083ea72d52a601230aa6f77874dcad9479f5bcac3763662cc30cb99823c5f"
+"f469dcbd64c028286b0e579580fd3a17b56b099b97bf62d555798f7a250e08b0e4f238c3"
+"fcf684198bd48a68c208a6268be2bb416eda3011b523388bce8357b7f26122640420461a"
+"bcabcb5004519adfa2d43db718bce7d0c8f1b4645c89315c65df1f0842e5741244bba3b5"
+"10801d2a446818635d0e8ffcd80c8a6f97ca9f878793b91780ee18eb6c2b99ffac3c38ef"
+"b7c6d3af0478317c2b9c421247eba8209ea677f984e2398c7c243696a12df2164417f602"
+"d7a1d33809c865b73397550ff33fe116166ae0ddbccd00e2b6fc538733830ac39c328018"
+"bcb87ac52474ad3cce8780d6002e14c6734f814cb551632bcc31965c1cd23d048b9509a4"
+"e22ab88f76a6dba209d5dd2febd1413a64d32be8574a22341f2a14e4bd879abb35627ef1"
+"35c37be0f80843006a7cc7158d2bb2a71bf536b36de20ca09bb5b674e5c408485106e6fa"
+"966e4f2139779b46f6010051615b5b41cda12d206d48e436b9f75d7e1398a656abb0087a"
+"a0eb453368fc1ecc71a31846080f804d7b67ad6a7aa48579c3a1435eff7577f4e6004d46"
+"aac4130293f6f62ae6d50c0d0c3b9876f0728923a94843785966a27555dd3ce68602e7d9"
+"0f7c7c552f9bda4969ec2dc3e30a70620db6300e822a93e633ab9a7a",
+   "5d4d18b24b877092188a44be4f2e80ab1d41e795",
+
+   7640,
+"1c87f48f4409c3682e2cf34c63286dd52701b6c14e08669851a6dc8fa15530ad3bef692c"
+"7d2bf02238644561069df19bdec3bccae5311fce877afc58c7628d08d32d9bd2dc1df0a6"
+"24360e505944219d211f33bff62e9ff2342ac86070240a420ccaf14908e6a93c1b27b6e2"
+"0324e522199e83692805cc4c7f3ea66f45a490a50d4dd558aa8e052c45c1a5dfad452674"
+"edc7149024c09024913f004ceee90577ff3eaec96a1eebbdc98b440ffeb0cad9c6224efc"
+"9267d2c192b53dc012fb53010926e362ef9d4238d00df9399f6cbb9acc389a7418007a6c"
+"a926c59359e3608b548bdeece213f4e581d02d273781dffe26905ec161956f6dfe1c008d"
+"6da8165d08f8062eea88e80c055b499f6ff8204ffdb303ab132d9b0cba1e5675f3525bbe"
+"4cf2c3f2b00506f58336b36aefd865d37827f2fad7d1e59105b52f1596ea19f848037dfe"
+"dc9136e824ead5505e2995d4c0769276548835430667f333fc77375125b29c1b1535602c"
+"10fe161864f49a98fc274ae7335a736be6bf0a98cd019d120b87881103f86c0a6efadd8c"
+"aa405b6855c384141b4f8751cc42dc0cb2913382210baaa84fe242ca66679472d815c08b"
+"f3d1a7c6b5705a3de17ad157522de1eb90c568a8a1fbcbb422cca293967bb14bfdd91bc5"
+"a9c4d2774dee524057e08f937f3e2bd8a04ced0fc7b16fb78a7b16ee9c6447d99e53d846"
+"3726c59066af25c317fc5c01f5dc9125809e63a55f1cd7bdf7f995ca3c2655f4c7ab940f"
+"2aa48bc3808961eb48b3a03c731ce627bb67dd0037206c5f2c442fc72704258548c6a9db"
+"e16da45e40da009dc8b2600347620eff8361346116b550087cb9e2ba6b1d6753622e8b22"
+"85589b90a8e93902aa17530104455699a1829efef153327639b2ae722d5680fec035575c"
+"3b48d9ec8c8e9550e15338cc76b203f3ab597c805a8c6482676deabc997a1e4ba857a889"
+"97ceba32431443c53d4d662dd5532aa177b373c93bf93122b72ed7a3189e0fa171dfabf0"
+"520edf4b9d5caef595c9a3a13830c190cf84bcf9c3596aadb2a674fbc2c951d135cb7525"
+"3ee6c59313444f48440a381e4b95f5086403beb19ff640603394931f15d36b1cc9f3924f"
+"794c965d4449bfbdd8b543194335bdf70616dc986b49582019ac2bf8e68cfd71ec67e0aa"
+"dff63db39e6a0ef207f74ec6108fae6b13f08a1e6ae01b813cb7ee40961f95f5be189c49"
+"c43fbf5c594f5968e4e820a1d38f105f2ff7a57e747e4d059ffb1d0788b7c3c772b9bc1f"
+"e147c723aca999015230d22c917730b935e902092f83e0a8e6db9a75d2626e0346e67e40"
+"8d5b815439dab8ccb8ea23f828fff6916c4047",
+   "32e0f5d40ceec1fbe45ddd151c76c0b3fef1c938",
+
+   8432,
+"084f04f8d44b333dca539ad2f45f1d94065fbb1d86d2ccf32f9486fe98f7c64011160ec0"
+"cd66c9c7478ed74fde7945b9c2a95cbe14cedea849978cc2d0c8eb0df48d4834030dfac2"
+"b043e793b6094a88be76b37f836a4f833467693f1aa331b97a5bbc3dbd694d96ce19d385"
+"c439b26bc16fc64919d0a5eab7ad255fbdb01fac6b2872c142a24aac69b9a20c4f2f07c9"
+"923c9f0220256b479c11c90903193d4e8f9e70a9dbdf796a49ca5c12a113d00afa844694"
+"de942601a93a5c2532031308ad63c0ded048633935f50a7e000e9695c1efc1e59c426080"
+"a7d1e69a93982a408f1f6a4769078f82f6e2b238b548e0d4af271adfa15aa02c5d7d7052"
+"6e00095ffb7b74cbee4185ab54385f2707e8362e8bd1596937026f6d95e700340b6338ce"
+"ba1ee854a621ce1e17a016354016200b1f98846aa46254ab15b7a128b1e840f494b2cdc9"
+"daccf14107c1e149a7fc27d33121a5cc31a4d74ea6945816a9b7a83850dc2c11d26d767e"
+"ec44c74b83bfd2ef8a17c37626ed80be10262fe63cf9f804b8460c16d62ae63c8dd0d124"
+"1d8aaac5f220e750cb68d8631b162d80afd6b9bf929875bf2e2bc8e2b30e05babd8336be"
+"31e41842673a66a68f0c5acd4d7572d0a77970f42199a4da26a56df6aad2fe420e0d5e34"
+"448eb2ed33afbfb35dffaba1bf92039df89c038bae3e11c02ea08aba5240c10ea88a45a1"
+"d0a8631b269bec99a28b39a3fc5b6b5d1381f7018f15638cc5274ab8dc56a62b2e9e4fee"
+"f172be20170b17ec72ff67b81c15299f165810222f6a001a281b5df1153a891206aca89e"
+"e7baa761a5af7c0493a3af840b9219e358b1ec1dd301f35d4d241b71ad70337bda42f0ea"
+"dc9434a93ed28f96b6ea073608a314a7272fefd69d030cf22ee6e520b848fa705ed6160f"
+"e54bd3bf5e89608506e882a16aced9c3cf80657cd03749f34977ced9749caa9f52b683e6"
+"4d96af371b293ef4e5053a8ea9422df9dd8be45d5574730f660e79bf4cbaa5f3c93a79b4"
+"0f0e4e86e0fd999ef4f26c509b0940c7a3eaf1f87c560ad89aff43cd1b9d4863aa3ebc41"
+"a3dd7e5b77372b6953dae497fc7f517efe99e553052e645e8be6a3aeb362900c75ce712d"
+"fcba712c4c25583728db9a883302939655ef118d603e13fcf421d0cea0f8fb7c49224681"
+"d013250defa7d4fd64b69b0b52e95142e4cc1fb6332486716a82a3b02818b25025ccd283"
+"198b07c7d9e08519c3c52c655db94f423912b9dc1c95f2315e44be819477e7ff6d2e3ccd"
+"daa6da27722aaadf142c2b09ce9472f7fd586f68b64d71fc653decebb4397bf7af30219f"
+"25c1d496514e3c73b952b8aa57f4a2bbf7dcd4a9e0456aaeb653ca2d9fa7e2e8a532b173"
+"5c4609e9c4f393dd70901393e898ed704db8e9b03b253357f333a66aba24495e7c3d1ad1"
+"b5200b7892554b59532ac63af3bdef590b57bd5df4fbf38d2b3fa540fa5bf89455802963"
+"036bd173fe3967ed1b7d",
+   "ee976e4ad3cad933b283649eff9ffdb41fcccb18",
+
+   9224,
+"bd8320703d0cac96a96aeefa3abf0f757456bf42b3e56f62070fc03e412d3b8f4e4e427b"
+"c47c4600bb423b96de6b4910c20bc5c476c45feb5b429d4b35088813836fa5060ceb26db"
+"bb9162e4acd683ef879a7e6a0d6549caf0f0482de8e7083d03ed2f583de1b3ef505f4b2c"
+"cd8a23d86c09d47ba05093c56f21a82c815223d777d0cabb7ee4550423b5deb6690f9394"
+"1862ae41590ea7a580dda79229d141a786215d75f77e74e1db9a03c9a7eb39eb35adf302"
+"5e26eb31ca2d2ca507edca77d9e7cfcfd136784f2117a2afafa87fa468f08d07d720c933"
+"f61820af442d260d172a0a113494ca169d33a3aeaacdcc895b356398ed85a871aba769f6"
+"071abd31e9f2f5834721d0fef6f6ee0fc0e38760b6835dfcc7dbefb592e1f0c3793af7ad"
+"f748786d3364f3cfd5686b1a18711af220e3637d8fad08c553ce9d5dc1183d48e8337b16"
+"1fe69b50e1920316dbffec07425b5d616a805a699576590e0939f5c965bce6c7342d314a"
+"c37b9c4d30166567c4f633f182de4d6b00e20a1c762789f915eaa1c89ac31b85222b1f05"
+"403dedd94db9ce75ff4e49923d1999d032695fa0a1c595617830c3c9a7ab758732fcec26"
+"85ae14350959b6a5f423ef726587e186b055a8daf6fa8fdefa02841b2fdbca1616dcee78"
+"c685fc6dcc09f24a36097572eba3c37a3eabe98bc23836085f63ef71a54b4488615d83b2"
+"6ed28c9fce78852df9b6cf8a75ca3899a7567298e91bc4ffdd04ffab0066b43b8286a4bb"
+"555c78808496b252c6e0e4d153631f11f68baf88630e052acc2af5d2af2e22e4f23bb630"
+"314c561a577455f86b6727bcad3c19d3e271404dec30af3d9dd0ed63cd9fa708aadfa12a"
+"500ef2d99a6b71e137b56ba90036975b88004b45f577ef800f0fb3cf97577dc9da37253b"
+"8675e5c8bb7e0bd26564f19eca232fb25f280f82e014424c9fbdd1411d7556e5d7906bb8"
+"62206316ba03385cd820c54c82ed35b36735bc486b1885d84053eba036c1ebfb5422d93d"
+"a71c53deda7f74db07cd4959cdfa898ba37080d76b564d344b124dd7b80cd70ed3b52a6c"
+"f9c9a32695d134bd39eb11ddeecdac86c808e469bd8a7995b667c452e7d9a54d5c85bcf6"
+"d5ffdc27d491bc06f438f02c7cf018073431587c78ba08d18a8daccb2d3b26136f612ade"
+"c673f3cd5eb83412b29652d55a10d0d6238d0b5365db272c917349450aff062c36191cfc"
+"d45660819083f89cd42ecae9e26934a020cafeb9b2b68d544edf59574c0ca159fd195dbf"
+"3e3e74244d942fffdbd4ed7f626219bab88b5a07e50b09a832d3e8ad82091114e54f2c35"
+"6b48e55e36589ebad3ac6077cb7b1827748b00670df65bbf0a2e65caad3f8a97d654d64e"
+"1c7dad171cafbc37110d2f7ca66524dc08fe60593e914128bd95f41137bfe819b5ca835f"
+"e5741344b5c907ce20a35f4f48726141c6398e753ed9d46d3692050628c78859d5014fe4"
+"dd3708e58d4d9807f8dac540492e32fa579491717ad4145c9efc24cf95605660b2e09b89"
+"9369b74d3ebff41e707917ff314d93e6ac8dfd643ef2c087cd9912005b4b2681da01a369"
+"42a756a3e22123cbf38c429373c6a8663130c24b24b2690b000013960b1c46a32d1d5397"
+"47",
+   "2df09b10933afedfcd3f2532dfd29e7cb6213859",
+
+   10016,
+"7a94978bec7f5034b12c96b86498068db28cd2726b676f54d81d8d7350804cc106bead8a"
+"252b465a1f413b1c41e5697f8cece49ec0dea4dfb9fa7b1bfe7a4a00981875b420d094bb"
+"1ce86c1b8c2e1dbebf819c176b926409fdec69042e324e71d7a8d75006f5a11f512811fe"
+"6af88a12f450e327950b18994dfc3f740631beda6c78bca5fe23d54e6509120e05cd1842"
+"d3639f1466cf26585030e5b4aefe0404fe900afc31e1980f0193579085342f1803c1ba27"
+"0568f80eaf92440c4f2186b736f6ab9dc7b7522ccdcfc8cf12b6375a2d721aa89b5ef482"
+"112a42c31123aebabcb485d0e72d6b6b70c44e12d2da98d1f87fa9df4f37847e1ffec823"
+"1b8be3d737d282ddb9cc4b95937acfa0f028ba450def4d134a7d0fc88119bf7296e18cd4"
+"4f56890b661b5b72ddfa34c29228067e13caf08eb3b7fd29de800df9a9ae137aad4a81a4"
+"16a301c9f74b66c0e163e243b3187996b36eb569de3d9c007d78df91f9b554eef0eaa663"
+"88754ce20460b75d95e2d0747229a1502a5652cf39ca58e1daa0e9321d7ab3093981cd70"
+"23a7ee956030dd70177028a66ad619ad0629e631f91228b7c5db8e81b276d3b168c1edb1"
+"bc0888d1cbcbb23245c2d8e40c1ff14bfe13f9c70e93a1939a5c45eef9351e795374b9e1"
+"b5c3a7bd642477ba7233e1f590ab44a8232c53099a3c0a6ffe8be8b7ca7b58e6fedf700f"
+"6f03dd7861ee1ef857e3f1a32a2e0baa591d0c7ca04cb231cc254d29cda873f00d68f465"
+"00d6101cfdc2e8004c1f333d8007325d06ffe6b0ff7b80f24ba51928e65aa3cb78752028"
+"27511207b089328bb60264595a2cebfc0b84d9899f5eca7ea3e1d2f0f053b4e67f975500"
+"7ff3705ca4178ab9c15b29dd99494135f35befbcec05691d91f6361cad9c9a32e0e65577"
+"f14d8dc66515081b51d09e3f6c25eea868cf519a83e80c935968cae6fce949a646ad53c5"
+"6ee1f07dda23daef3443310bc04670afedb1a0132a04cb64fa84b4af4b3dc501044849cd"
+"dd4adb8d733d1eac9c73afa4f7d75864c87787f4033ffe5ba707cbc14dd17bd1014b8b61"
+"509c1f55a25cf6c0cbe49e4ddcc9e4de3fa38f7203134e4c7404ee52ef30d0b3f4e69bcc"
+"7d0b2e4d8e60d9970e02cc69d537cfbc066734eb9f690a174e0194ca87a6fadad3883d91"
+"6bd1700a052b26deee832701590d67e6f78938eac7c4beef3061a3474dd90dd588c1cd6e"
+"6a4cda85b110fd08a30dcd85a3ebde910283366a17a100db920885600db7578be46bcfa6"
+"4765ba9a8d6d5010cb1766d5a645e48365ed785e4b1d8c7c233c76291c92ef89d70bc77f"
+"bf37d7ce9996367e5b13b08242ce73971f1e0c6ff2d7920fb9c821768a888a7fe0734908"
+"33efb854cbf482aed5cb594fb715ec82a110130664164db488666d6198279006c1aa521f"
+"9cf04250476c934eba0914fd586f62d6c5825b8cf82cd7ef915d93106c506ea6760fd8b0"
+"bf39875cd1036b28417de54783173446026330ef701c3a6e5b6873b2025a2c1666bb9e41"
+"a40adb4a81c1052047dabe2ad092df2ae06d6d67b87ac90be7d826ca647940c4da264cad"
+"43c32a2bb8d5e27f87414e6887561444a80ed879ce91af13e0fbd6af1b5fa497ad0cbd2e"
+"7f0f898f52f9e4710de2174e55ad07c45f8ead3b02cac6c811becc51e72324f2439099a0"
+"5740090c1b165ecae7dec0b341d60a88f46d7ad8624aac231a90c93fad61fcfbbea12503"
+"59fcd203862a6b0f1d71ac43db6c58a6b60c2c546edc12dd658998e8",
+   "f32e70862a16e3e8b199e9d81a9949d66f812cad",
+
+   10808,
+"88dd7f273acbe799219c23184782ac0b07bade2bc46b4f8adbd25ed3d59c0fd3e2931638"
+"837d31998641bbb7374c7f03d533ca60439ac4290054ff7659cc519bdda3dff2129a7bdb"
+"66b3300068931ade382b7b813c970c8e15469187d25cb04b635403dc50ea6c65ab38a97c"
+"431f28a41ae81c16192bd0c103f03b8fa815d6ea5bf0aa7fa534ad413b194eb12eb74f5d"
+"62b3d3a7411eb8c8b09a261542bf6880acbdfb617a42e577009e482992253712f8d4c8bd"
+"1c386bad068c7aa10a22111640041f0c35dabd0de00ebf6cd82f89cbc49325df12419278"
+"ec0d5ebb670577b2fe0c3e0840c5dd0dc5b3da00669eed8ead380f968b00d42f4967faec"
+"c131425fce1f7edb01cbec7e96d3c26fa6390a659e0ab069ef3edadc07e077bb816f1b22"
+"98830a0fe2b393693bb79f41feca89577c5230e0a6c34b860dc1fdb10d85aa054481082c"
+"494779d59ba798fcd817116c3059b7831857d0364352b354ce3b960fbb61a1b8a04d47ca"
+"a0ead52a9bea4bada2646cdbaec211f391dac22f2c5b8748e36bfc3d4e8ea45131ca7f52"
+"af09df21babe776fcecbb5c5dfa352c790ab27b9a5e74242bbd23970368dbefd7c3c74d1"
+"61ae01c7e13c65b415f38aa660f51b69ea1c9a504fe1ad31987cb9b26a4db2c37d7b326c"
+"50dbc8c91b13925306ff0e6098532dee7282a99c3ddf99f9e1024301f76e31e58271870b"
+"d94b9356e892a6a798d422a48c7fd5b80efe855a4925cc93b8cf27badec5498338e2b538"
+"70758b45d3e7a2fa059ed88df320a65e0a7cf87fa7e63b74cea1b7371e221f8004726642"
+"30d4d57945a85b23d58f248c8cd06ccfabfa969ab8cb78317451fab60e4fdfa796e2e2a8"
+"b46405839a91266d37e8d38bae545fb4060c357923b86d62f5d59d7bef5af20fbb9c7fb4"
+"2c6fd487748ed3b9973dbf4b1f2c9615129fa10d21cc49c622842c37c01670be71715765"
+"a98814634efbdee66bf3420f284dbd3efafc8a9117a8b9a72d9b81aa53ded78c409f3f90"
+"bad6e30d5229e26f4f0cea7ee82c09e3b60ec0e768f35a7fb9007b869f9bfc49c518f648"
+"3c951d3b6e22505453266ec4e7fe6a80dbe6a2458a1d6cd93044f2955607412091009c7d"
+"6cd81648a3b0603c92bfdff9ec3c0104b07ed2105962ca7c56ede91cb932073c337665e2"
+"409387549f9a46da05bc21c5126bd4b084bc2c06ab1019c51df30581aa4464ab92978c13"
+"f6d7c7ac8d30a78f982b9a43181bbe3c3eb9f7a1230b3e53b98a3c2a028317827fbe8cf6"
+"ec5e3e6b2a084d517d472b25f72fab3a34415bba488f14e7f621cfa72396ba40890e8c60"
+"b04815601a0819c9bebc5e18b95e04be3f9c156bd7375d8cc8a97c13ce0a3976123419fa"
+"592631317ca638c1182be06886f9663d0e8e6839573df8f52219eeb5381482a6a1681a64"
+"173660bfbb6d98bf06ee31e601ee99b4b99b5671ed0253260b3077ed5b977c6a79b4ff9a"
+"08efd3cba5c39bec1a1e9807d40bbf0c988e0fd071cf2155ed7b014c88683cd869783a95"
+"4cbfced9c0e80c3a92d45b508985cbbc533ba868c0dc4f112e99400345cf7524e42bf234"
+"5a129e53da4051c429af2ef09aba33ae3c820ec1529132a203bd2b81534f2e865265f55c"
+"9395caf0e0d3e1762c95eaaec935e765dc963b3e0d0a04b28373ab560fa9ba5ca71ced5d"
+"17bb8b56f314f6f0d0bc8104b3f1835eca7eaac15adf912cf9a6945cfd1de392342dd596"
+"d67e7ffcb7e086a6c1ea318aa2e0c2b5c2da079078232c637de0d317a1f26640bc1dac5b"
+"e8699b53edc86e4bfdfaf797a2ae350bf4ea29790face675c4d2e85b8f37a694c91f6a14"
+"1fd561274392ee6ee1a14424d5c134a69bcb4333079400f03615952fc4c99bf03f5733a8"
+"dc71524269fc5c648371f5f3098314d9d10258",
+   "08632c75676571a5db5971f5d99cb8de6bf1792a",
+
+   11600,
+"85d43615942fcaa449329fd1fe9efb17545eb252cac752228f1e9d90955a3cf4e72cb116"
+"3c3d8e93ccb7e4826206ff58b3e05009ee82ab70943db3f18a32925d6d5aed1525c91673"
+"bd33846571af815b09bb236466807d935b5816a8be8e9becbe65d05d765bcc0bc3ae66c2"
+"5320ebe9fff712aa5b4931548b76b0fd58f6be6b83554435587b1725873172e130e1a3ca"
+"3d9d0425f4632d79cca0683780f266a0633230e4f3b25f87b0c390092f7b13c66ab5e31b"
+"5a58dbcac8dd26a0600bf85507057bb36e870dfae76da8847875a1a52e4596d5b4b0a211"
+"2435d27e1dc8dd5016d60feaf2838746d436a2983457b72e3357059b2bf1e9148bb0551a"
+"e2b27d5a39abd3d1a62c36331e26668e8baabc2a1ef218b5e7a51a9ca35795bcd54f403a"
+"188eafafb30d82896e45ddaea4f418629a1fb76a0f539c7114317bac1e2a8fba5a868bce"
+"40abd40f6b9ced3fa8c0329b4de5ca03cc84d75b8746ef31e6c8d0a0a79b4f747690928e"
+"be327f8bbe9374a0df4c39c845bf3322a49fda9455b36db5a9d6e4ea7d4326cf0e0f7cd8"
+"0ff74538f95cec01a38c188d1243221e9272ccc1053e30787c4cf697043cca6fc3730d2a"
+"431ecbf60d73ee667a3ab114c68d578c66dc1c659b346cb148c053980190353f6499bfef"
+"acfd1d73838d6dc1188c74dd72b690fb0481eee481a3fd9af1d4233f05d5ae33a7b10d7d"
+"d643406cb1f88d7dd1d77580dcbee6f757eeb2bfbcc940f2cddb820b2718264b1a64115c"
+"b85909352c44b13d4e70bbb374a8594d8af7f41f65b221bf54b8d1a7f8f9c7da563550cb"
+"2b062e7a7f21d5e07dd9da8d82e5a89074627597551c745718094c2eb316ca077526d27f"
+"9a589c461d891dc7cd1bc20ba3f464da53c97924219c87a0f683dfb3b3ac8793c59e78ac"
+"fac109439221ac599a6fd8d2754946d6bcba60784805f7958c9e34ff287ad1dbbc888848"
+"fa80cc4200dbb8c5e4224535906cbffdd0237a77a906c10ced740f9c0ce7821f2dbf8c8d"
+"7d41ecfcc7dfdc0846b98c78b765d01fb1eb15ff39149ab592e5dd1152665304bba85bbf"
+"4705751985aaaf31245361554d561a2337e3daeef58a826492fd886d5f18ef568c1e772e"
+"f6461170407695e3254eb7bf0c683811ddde5960140d959114998f08bdb24a104095987d"
+"3255d590e0dbd41ae32b1ae4f4ea4a4f011de1388034231e034756870c9f2d9f23788723"
+"27055a7de2b5e931dfb53e7780b6d4294bf094e08567025b026db9203b681565a1d52f30"
+"318d0ebe49471b22ba5fd62e1ed6c8966c99b853c9062246a1ace51ef7523c7bf93bef53"
+"d8a9cb96d6a04f0da1eca888df66e0380a72525a7ecc6115d08569a66248f6ba34e2341b"
+"fd01a78f7b3c1cfe0754e0d26cba2fa3f951ef14d5749ff8933b8aba06fa40fb570b467c"
+"54ce0d3f0bed21e998e5a36b3bc2f9e1ae29c4bab59c121af6fad67c0b45959cd6a86194"
+"14b90b4535fb95f86ca7e64502acc135eff4f8a3abe9dde84238fab7a7d402454a3f07ad"
+"ec05ec94b2891e0879037fae6acaa31dcecf3f85236ade946f5ad69ad4077beb65099285"
+"38ee09f2bc38e5704da67b5006b5e39cd765aafcd740c7dadb99d0c547126e1324610fcb"
+"7353dac2c110e803fca2b17485b1c4b78690bc4f867e6f043b2568889f67985a465a48eb"
+"ee915200589e915756d4968d26529c3ffe3dbe70e84c682ad08a0c68db571634fbb0210d"
+"c1b16b8b725886465c8c51f36a5e27d0f78e5643e051d3bddd512ce511f6bdf3dfe42759"
+"00c5fea9d248c2b3f36911ed0ff41a19f6445521f251724657ea8f795b3ead0928a1657f"
+"308dd7c7c1e7e490d9849df43becfa5cc25ed09ef614fd69ddc7e5e3147623901d647876"
+"fb60077ffc48c51ed7d02b35f6802e3715fc708a0c88b82fe9cba0a442d38d09ca5ae483"
+"21487bdef1794e7636bf7457dd2b51a391880c34d229438347e5fec8555fe263f08ba87b"
+"b16dcde529248a477628067d13d0cb3bf51776f4d39fb3fbc5f669e91019323e40360e4b"
+"78b6584f077bf9e03b66",
+   "ab7213f6becb980d40dc89fbda0ca39f225a2d33",
+
+   12392,
+"7ae3ca60b3a96be914d24980fb5652eb68451fed5fa47abe8e771db8301fbd5331e64753"
+"93d96a4010d6551701e5c23f7ecb33bec7dd7bade21381e9865d410c383a139cb4863082"
+"8e9372bd197c5b5788b6599853e8487bddfd395e537772fdd706b6a1de59c695d63427da"
+"0dc3261bce2e1ae3cd6de90ec45ecd7e5f14580f5672b6ccd8f9336330dffcd6a3612a74"
+"975afc08fb136450e25dc6b071ddfc28fca89d846c107fd2e4bd7a19a4ff6f482d62896d"
+"a583c3277e23ab5e537a653112cdf2306043b3cc39f5280bd744fe81d66f497b95650e7d"
+"dfd704efcb929b13e00c3e3a7d3cd53878af8f1506d9de05dba9c39a92604b394ea25acb"
+"a2cda7b4ae8b08098ba3f0fdea15359df76517be84377f33631c844313ac335aa0d590fe"
+"c472d805521f0905d44ca40d7391b292184105acd142c083761c1a038c4f5ed869ea3696"
+"99592a37817f64cb4205b66be1f1de6fa47a08e1bf1a94312fe61a29e71bab242af95a7b"
+"38d4fb412c682b30256d91e2a46b634535d02b495240cbdb842cbe17cba6a2b94073f3d5"
+"f9621ac92ddda66f98bed997216466b4bb0579d58945f8d7450808d9e285d4f1709d8a1d"
+"416aa57d4a1a72bfcbfecdda33de2cff3e90e0cc60c897c4663224fc5bbe8316a83c1773"
+"802837a57bc7e9238173ed41ea32fe5fe38e546014a16d5e80700d9bac7a84bb03902f31"
+"79e641f86f6bc383d656daf69801499633fb367ea7593195934c72bc9bf9624c0c845ebf"
+"c36eb7ad4b22fdfb45ca7d4f0d6708c69a21f6eaa6db6bde0f0bd9dc7ec9c6e24626d0a7"
+"8fbeeed4b391f871e80e6a9d207165832d4ff689296f9bca15dc03c7c0381659ea5335eb"
+"aafdc3e50d18e46b00f1844870d09c25afcdb0ff1ae69dd8f94f91aca6095ba6f2b6e594"
+"c4acfe9903485d21b684e31a6acc2162d40e1a7bb8114a860a07e76f5265666555f2418d"
+"f11ef8f7499656d12215f5da8d7d041ac72648d15d7661ad93b24f3f071334b0921d5bb0"
+"6f2c7ab09f5034518b5ae21cec379373e87d51c77d44a70c2337606aadeb9036716fd920"
+"a824e7ae18ce3de9f0ec3456f3454027d8c476b3f1854b240c309f6f9786fa8a073915d9"
+"7a019ce99aec3260c5f6b6346cd9c41cb9267f4475958e45289965548238c6b9f91a8784"
+"b4e0957ba8b73956012c9a2fc3428434b1c1679f6ed2a3e8e2c90238df428622046f668e"
+"e2b053f55e64ffd45600e05a885e3264af573bacee93d23d72a0222b5442ac80bc0a8b79"
+"4c2afcf3bc881d20c111f57e3450b50a703f3db1fc5de2076a006f3b7eed694b93269874"
+"3b03c2ed2684bad445e69a692e744c7ac3a04f1e0e52b7a6708076d1fbffdb3f1c995828"
+"7d5f884e29407030f2db06811092efd80ae08da9daec39744c5ecd3ca771663b8f4968d4"
+"2a88c2c9821c73ae2a5a4d9e2551f82c03583b9c4dea775423b4748d24eb604e8ee3159b"
+"a6de9bea5b22eed6264e011734ed02b2c74ce06dda890b8604ed7ba49e7bf30e28c9871b"
+"e90f5cead67eaf52b5d3181c822b10701219b28ef6f6bebfa278e38acf863e2a1d4b1e40"
+"fd8a0ac6ce31054446301046148bf10dc3ae3385e2026e7762bdc8003ffebc4263191a59"
+"c72f4f90db03e7d52808506b33bfe1dfa53f1a3daa152e83974fbe56cfd4e8f4e7f7806a"
+"084b9d0795b858100eced0b5355a72446f37779d6c67ade60a627b8077ae1f3996b03bc3"
+"a5c290651c8609f0d879fbf578cbab35086e1159dd6ddbe3bf7fb5654edcc8f09e4f80d0"
+"258c9376d7c53fb68f78d333b18b70170d9a11070790c956f5744c78c986b1baf08b7631"
+"7a65c5f07ae6f57eb0e65488659324d29709e3735623d0426e90aa8c4629bb080881150c"
+"02be1c004da84414ac001c2eb6138c26388f5a36d594f3acef0e69e2cb43b870efa84da0"
+"cff9c923a9880202aed64ad76260f53c45bb1584b3e388a909d13586094b924680006a1d"
+"25d4dd36c579a8ec9d3fa63c082d977a5a5021440b5314b51850f2daa6e6af6ae88cb5b1"
+"44242bceb1d4771e641101f8abfc3a9b19f2de64e35e76458ad22072ba57925d73015de5"
+"66c66fcaa28fdc656f90de967ad51afd331e246d74ed469d63dd7d219935c59984bd9629"
+"09d1af296eb3121d782650e7d038063bab5fa854aac77de5ffebeb53d263f521e3fc02ac"
+"70",
+   "b0e15d39025f5263e3efa255c1868d4a37041382",
+
+   13184,
+"fa922061131282d91217a9ff07463843ae34ff7f8c28b6d93b23f1ea031d5020aa92f660"
+"8c3d3df0ee24a8958fd41af880ee454e36e26438defb2de8f09c018607c967d2f0e8b80a"
+"00c91c0eabe5b4c253e319b45e6106ff8bf0516f866020e5ba3f59fd669c5aeff310ebb3"
+"85007069d01c64f72d2b02f4ec0b45c5ecf313056afcb52b17e08b666d01fecc42adb5b4"
+"9ea00c60cacac2e0a953f1324bdd44aec00964a22a3cb33916a33da10d74ec6c6577fb37"
+"5dc6ac8a6ad13e00cba419a8636d4daac8383a2e98fe90790cde7b59cfaa17c410a52abc"
+"d68b127593d2fcbafd30578d195d890e981ae09e6772cb4382404a4e09f1a33c958b57db"
+"ccee54ae335b6c91443206a0c100135647b844f226417a1f70317fd350d9f3789d81894a"
+"aff4730072401aaeb8b713ead4394e2e64b6917d6eee2549af7bd0952f12035719065320"
+"ca0d2dfe2847c6a2357c52bee4a676b12bafff66597bd479aa29299c1896f63a7523a85a"
+"b7b916c5930ab66b4d191103cefc74f2f7e0e96e354f65e355ae43959a0af1880d14ea9d"
+"1569e4fd47174aba7f5decb430b3f6baf80a1ef27855227b62487250d3602970e423423c"
+"7ca90920685bcf75adfbe2a61ce5bd9228947b32f567927cb1a5bd8727c03aef91d6367b"
+"ae7d86fd15c0977ac965a88b0d7236037aefb8d24eec8d2a07c633e031a7b9147c4c7714"
+"110bfc7e261448a5d0f73c3619664e1c533c81a0acbf95d502227a33f84f0b8249e3f9fa"
+"5c7905a8192b7313fc56bb20679e81333d32c797ac5162204a0eaa0e64507635921c485b"
+"8f17c4e2484667a733197529e2a833eed83c57229b11bd820b5a5b78f1867787dbc217ea"
+"28bfba785fb545cbc5a840a12eea428213e1aaa4e50a900ba13efcf4a5345574c2481c5d"
+"927ada610bba567a55630c89d905db3d9b67fe36c9cc3d6a947664c83e69f51c74711a33"
+"df66dd3ff6af9b7c1605b614d4798b4192b9a4b1508f2e2ec5aaad7eaea1ee8867353db9"
+"b8d7d9a6f16aa5f339492073238c979082879aee7f94ac4be8133eaacbaedfb044e2ad4e"
+"93ba0fa071dea615a5cd80d1d2678f4f93ae5a4bc9cdf3df345a29ec41d8febb23805ce4"
+"2541036f3f05c63ae736f79a29802045fad9f370cabf843458c1b636ca41f387fd7821c9"
+"1abbd1946afcb9186b936403233f28a5b467595131a6bc07b0873e51a08de66b5d7709a6"
+"02c1bd0e7f6e8f4beb0579c51bda0e0c738ef876fcd9a40ab7873c9c31c1d63a588eebc7"
+"8d9a0ae6fa35cd1a269e0d2bc68252cbd7c08d79e96f0aa6be22a016136a2b8abe9d3c9c"
+"f9d60eeafe3dbc76d489b24d68c36167df4c38cf2b21cf03dc5e659e39018c3490f1237e"
+"ca3f85b742ab0045d86a899c4126ad60a147cbc95b71814c274d6478668df41eb32acfb4"
+"bbf024fb4e3d6be0b60653a0471afc3037ab67dcb00a2b2e24b26911e1880136e56106b7"
+"f3c570fbe6f311d94624cb001914ff96fbbf481f71686aa17be0850568058fc1ee8900b4"
+"7af5cf51c5ed9e00a8b532c131f42513f6b8df14a9bbc2e9ede5a560681184d41a147552"
+"edfbdef98d95e6a7793229d25ba9b0b395a020aa1c0731de89e662246d59ec22e5d8f4b4"
+"6fbc048efcffbc234744c5c66417070f9c751c81788f04691ccb1a09d60c46f6f73375bf"
+"e2e646cf6290069541a8dfe216374c925e94d06ece72e851e81d3e8acd011f82526c2f9f"
+"55955c6752dc10e93153ab58627e30fa2c573e4042954337982eec1f741be058c85bad86"
+"bf3a02ed96d3201dadd48bd4de8105200dfcbcc400c3c3dd717abfc562ebe338b14b1eb5"
+"ecbe9227661e49c58bf8233770d813faafc78b05711135adcc4ce4c65095ca0bdc1debc0"
+"b6e5d195dbc582ce94b3afa14a422edf9b69abd7ae869a78c3a26fb50ef7122ec5af8d0c"
+"78ef082ca114f8817c3d93b31809870caea2eb9533fa767c2954efb9ba07e4f1077e9f9b"
+"be845661eabea2c91079321477a7c167c7234528d63d6aabbe723e0e337b2e61138a310a"
+"3fd04368aa4215b7af9d0334a8a74681bcb86b4af87a0329a1ed9dc7c9aef14521785eda"
+"0eeb97bdff8c9945fd0ee04e84d0dae091a69c0bfcdcd4150878fed839c0db6565fc1fed"
+"0e7d6ae2efde7a59d58a9fb3b07e6f7cea51ba93f771c18b2eafa252d7fe171085776052"
+"a6a17e6858f0a20b7e8be54413523989bf20a028a84d9ce98b78e6ee0b8362df49de5344"
+"b409cc322354672a21ea383e870d047551a3af71aaf2f44f49a859cf001e61b592dd036f"
+"c6625bf7b91ea0fb78c1563cceb8c4345bf4a9fbe6ee2b6bf5e81083",
+   "8b6d59106f04300cb57c7c961945cd77f3536b0a",
+
+   13976,
+"162cca41155de90f6e4b76a34261be6666ef65bdb92b5831b47604ce42e0c6c8d2eda265"
+"ab9a3716809bf2e745e7831a41768d0f6349a268d9ac6e6adfb832a5d51b75d7951cf60e"
+"03d9e40de6d351f1f6ade5143531cf32839401ca6dfb9dc7473daa607aeb0c3d1e8eb3db"
+"cc2f1231ad1dd394d7eac9d8dab726b895b1ee774fdcabc8031063ecfa41c71a9f03ad23"
+"904cc056f17c76a1059c43faffe30dfd157fdfd7d792e162bf7a889109550a0fc4c41523"
+"2af0c0d72dcbc2595299e1a1c2aeae549f7970e994c15e0ab02f113d740d38c32a4d8ec0"
+"79cd099d37d954ab7ef2800902cdf7c7a19fb14b3c98aaf4c6ad93fe9a9bc7a61229828e"
+"55ad4d6270d1bdbca9975d450f9be91e5699bd7ee22e8c9c22e355cf1f6793f3551cb510"
+"c1d5cd363bdf8cab063e6e49a6383221f1188d64692c1f84c910a696de2e72fb9886193f"
+"61ab6b41ad0ea894d37ff1261bf1fd1f187e0d0c38ab223d99ec6d6b1e6b079fc305e24e"
+"2d9500c98676e2d587434495d6e107b193c06fb12d5d8eaa7b0c001d08f4d91cae5bdcae"
+"6624ee755e95ca8e4c5ef5b903d7f5ba438abeffd6f16d82d88138f157e7a50d1c91fb50"
+"c770f6d222fcbf6daf791b1f8379e3b157a3b496ddb2e71650c1c4ac4fc5f2aceb5b3228"
+"ffc44e15c02d4baa9434e60928a93f21bc91cfd3c2719f53a8c9bcd2f2dee65a8bbc88f9"
+"5d7ced211fc3b04f6e8b74eb2026d66fd57fa0cccea43f0a0381782e6fee5660afed674d"
+"cb2c28cb54d2bdbbaf78e534b0742ede6b5e659b46cd516d5362a194dd0822f6417935c4"
+"ff05815b118fe5687cd8b050240015cfe449d9dfde1f4fdb105586e429b2c1849aac2791"
+"ef73bc54603190eba39037ec057e784bb92d497e705dfcde2addb3514b4f1926f12d5440"
+"850935779019b23bd0f2977a8c9478c424a7eaaeec04f3743a77bee2bec3937412e707bc"
+"92a070046e2f9c35fe5cc3f755bbb91a182e683591ab7e8cff40633730546e81522f588f"
+"07bdf142b78e115d2a22d2eb5664fcdb7574c1ee5ba9abd307d7d29078cd5223c222fc69"
+"60324c40cc639be84dad96b01059efce7b08538ebef89bafab834609c7e82774a14e5be6"
+"62067edba6111efa8ae270f5066442b17e3f31a793581c8a3f96d92921ec26981594e28a"
+"08987d020b97ad2ba5c662836e35fd3fd954bcec52b579528913959d0d942fbf1c4b9910"
+"ba010c3700359a4eb7616541257f0f7727cc71b580cc903f718ecc408a315b6bbfa7f6e3"
+"beb9d258804bd2731ee2fb75e763281baf1effc4690a23d5f952ab5d4311d4f5885af2eb"
+"f27cad9f6d84692cb903064bbd11ca751f919b4811b7722c6ec80c360521e34d357b5c8b"
+"ba6d42e5c632730f53add99ab8aa9c607b6796216753086ede158bc670d04900aca66ce8"
+"357bd72d19fb147b5fde8ee4df6a0184573a2e65ba3fd3a0cb04dac5eb36d17d2f639a6e"
+"b602645f3ab4da9de4c9999d6506e8e242a5a3216f9e79a4202558ecdc74249ad3caaf90"
+"71b4e653338b48b3ba3e9daf1e51e49384268d63f37ce87c6335de79175cdf542d661bcd"
+"74b8f5107d6ab492f54b7c3c31257ecb0b426b77ed2e2ed22bbfdaf49653e1d54e5988fa"
+"d71397546f9955659f22b3a4117fc823a1e87d6fb6fb8ab7d302a1316975e8baf0c0adbd"
+"35455655f6a596b6ac3be7c9a8ea34166119d5e70dfbc1aa6e14ff98eff95e94ef576656"
+"5d368ec8857fb0b029bcb990d420a5ca6bc7ab08053eb4dbfc4612a345d56faefc5e03a4"
+"43520b224de776a5b618e1aa16edc513d5fcefcd413031b0ddc958a6fca45d108fbde065"
+"3cf2d11cb00a71cd35f57993875598b4e33e2384623a0986859105d511c717c21d6534bf"
+"69fd3d7cf1682e4fc25298d90df951e77a316996beac61bb7078988118c906548af92cfe"
+"72cd4b102ffad584e5e721a0cdb5621ed07dda8955d84bea57a5afa4ba06289ddfac3a9e"
+"765538fd9392fc7904cedb65e38cd90967f01845ff819777a22d199f608e62c13e6ba98b"
+"40824b38c784bdb41d62c4014fc7e8d93be52695e975e54d1ff92b412f451177143d74a6"
+"bde0ee53a986043ab465a1ef315ac4c538e775ef4178fde5f2ea560a364de18b8fe9578a"
+"ad80027c3fd32dcf0967d9d03789b1cdf19040762f626289cf3af8afe5a8e0a152d9258e"
+"981872c1ec95cd7f8d65812e55cb5cbd8db61b3f068a23d9652372dfbf18d43a663c5a0d"
+"026b0898e383ce5c95b0ba7fb5ed6b7304c7c9d3ba64f38d1dc579465148ccfa7271f2e3"
+"e0e97e9ddac7c0874f0f396cf07851638a734df393687b7b0343afd1652ff32a2da17b3a"
+"4c99d79c02256c73f32625527e5666594a8a42a12135eddb022e743371b3ab7b12ad6785"
+"7635eed03558ac673d17280769b2368056276d5d72f5dbc75525f8a7558bd90b544aa6cb"
+"dd964e6c70be79441969bfdf471f17a2dc0c92",
+   "6144c4786145852e2a01b20604c369d1b9721019",
+
+   14768,
+"c9bed88d93806b89c2d028866842e6542ab88c895228c96c1f9f05125f8697c7402538b0"
+"6465b7ae33daef847500f73d20c598c86e4804e633e1c4466e61f3ed1e9baadc5723bbed"
+"9455a2ff4f99b852cfe6aa3442852ade0b18e4995ddab4250928165a9441de108d4a293d"
+"1d95935de022aa17f366a31d4f4c4c54557a4235a9d56473444787ddc5c06c87087aef24"
+"fa8280b7ac74d76ba685e4be7dc705e5a8a97c6c8fbd201ee5bf522438d23371c60c155d"
+"93352f8fb8cc9421fe4b66ffabad46909c2c1099944fc55ed424c90aecca4f50d0331153"
+"2e2844c3ff8ecb495de7ab26941cbf177b79ad7b05f918b713c417da8cf6e67db0a2dcee"
+"a9179d8d636191759e13955f4244f0c4f2d88842e3015641ef0417d6e54144e8246e4591"
+"6823e2c6e39bfa3b90b97781c44981710689f2ce20e70a26760d65f9971b291e12338461"
+"8b3b56710dde2afaa2d46b0e2164d5c9482729350a0e256b2aa6b3fb099b618ebd7c11ca"
+"62bdf176b502aedfdf9be57a8e4adbca4a4d6d8407984af2f6635f95a1e4930e375eb53f"
+"245ab2ade5340c281bda87afded1268e537955c9819168bd60fd440533c75c9b1865e03f"
+"de3a301d165f97aa6da236cf39cf3e49512f6350224f8d76ff02d0d3b9a99e5f70b23b9f"
+"a85f72849fc98790df246c3a0f4437940e60d42b4317f72e2eb055d343a614f7f9648005"
+"1e4dff186dff476462d9ced24dbb82eaa60cbbf6a0026e64001da36d30f529f48f3688b1"
+"0ce9378ef3f50f5106e5007cd0eb037136254fda4f20d048769bd51a9d8d09a1e469a482"
+"6aa0e25b6267b5a96abcb6e919a362fdd7b683d2f2dcec40ee5969311c07f6066ee22f36"
+"89ca08381c85bea470040e9541e7a451cd43d62c2aa292a9dc4b95e3a7c4de2ba29663f3"
+"8d5002eb64ceba6934bb1b0e2e55fba7fa706b514ebeeae1be4dd882d6512da066246a05"
+"1d8bd042593bd0513e9cc47806ccdc7097e75bc75b8603834c85cd084e0ade3cc2c2b7e8"
+"586eac62249f9769f5bdcd50e24e515f257548762db9adf3ee0846d67cfcd723d85d9588"
+"09e6dd406f4c2637557c356fc52490a2a0763429ee298a1c72c098bb810e740c15faffc6"
+"1e80cf6e18f86dc0e29bc150ce43ca71f5729356cd966277fd8b32366f6263c3a761b13d"
+"544a631a25e1c4c8dea8d794abed47ccb4069d20f1dcb54e40a673ffb5f7b2eb31fb7d44"
+"36fd8252f92dc35bb9a18fc55099b17e0807e79caf4f9641ee4bbbc2d6922508bcfae236"
+"475bf78bc796548bc8d60659e816af68e5e43352fa64b5086c97c22c60ddcbbbefb9d9ef"
+"7cd57c64454604793910f4f90aedb4fb824a86061a93bb79c9b0272a1ad0d24e8165f099"
+"ef6f14a6a4fea09845f280022e061804090d7ab79f7bddcbef264b6f7d4e9971eddb9ca7"
+"d0e79a8dbe7cff2fa59f514a608d66ae8c44d5e69745aa1b19995e366812064567d3ca20"
+"9e12994c901d1b1f489be7253615f7c339b5581afd4d262e879ab8480ecb18990d3db61f"
+"96895dcde9c065e645f52baafefcbe34d072dba373fd1c786fd56c3f3284be7260eaff9a"
+"6a8348b762ed59e20ea443313b1164db53c3989c32fcae5b366f190b9548e8cff46df961"
+"350369b490354ed8e530a91f5072967eff45c63540862fb2deab02b3ae05deac65414368"
+"ac3549f277da92b692947de47cba9c1579526931e31c3490c1d3605f9bafcf468c2e9b47"
+"981407ea40b0b59754621943095a2d4f4ba266ac545fe7447e54f69555a7ac9ff1e8f001"
+"834fa65f2d4523061726e4d3bf4680519032dc21b7389e9f3229e4c2295d354482f8b803"
+"b06ca3a8cb3ff786e60f6bc59dd3a5bfed63b0aa493bab78e97bbefb6633534d84de826f"
+"4e2ccc3069050d50a2caace6c9de15ffc2656988d94b736e5688df0351a3a6a4c875cd99"
+"ef304f3cc7a0585df2b0b3e6c62f86bba0d43de47b80c4eec1c4f98e60a36188219919cf"
+"36dc10ee11e174a67d226ad9e71f02a7fca26ad67a4862773f3defc6a747545314063e5f"
+"ce7a3f890ec57daa5532acfd027739832437c8a58dcbe11c2842e60e8ca64979d081fbd5"
+"a1a028f59317212fb5869abc689a156171d69e4f4c93b949c3459904c00192d3603cd184"
+"48d64b843c57f34aee7830f313e58e2abc41b44be46a96c845ffebcb7120e21d1d751046"
+"c072adf65dd901a39c8019742054be5e159ea88d0885ee05fcd4c189bafe5abb68603186"
+"5dc570b9342fa7f41fd5c1c87e68371ab19a83c82ae1d890c678102d5da8e6c29845657c"
+"027ba07362cba4d24950ab38e747925e22ce8df9eaec1ae2c6d23374b360c8352feb6cb9"
+"913e4fc49bde6caf5293030d0d234a8ecd616023cc668262591f812de208738e5336a9e6"
+"9f9be2479b86be1e1369761518dfc93797ed3a55308878a944581eba50bc9c7f7a0e75c7"
+"6a28acd95b277857726f3f684eefc215e0a696f47d65d30431d710d957c08ef96682b385"
+"0ee5ba1c8417aafc1af2846a127ec155b4b7fb369e90eb3a5c3793a3389bbc6b532ca32b"
+"f5e1f03c2280e71c6e1ae21312d4ff163eee16ebb1fdee8e887bb0d453829b4e6ed5fa70"
+"8f2053f29b81e277be46",
+   "a757ead499a6ec3d8ab9814f839117354ae563c8"
+};
+
+void test_sha1(void)
+{
+   unsigned char buffer[4000];
+   int i;
+   for (i=0; i < sizeof(sha1_tests) / sizeof(sha1_tests[0]); ++i) {
+      stb_uint len = sha1_tests[i].length / 8;
+      unsigned char digest[20], fdig[20];
+      unsigned int h;
+      assert(len <= sizeof(buffer));
+      assert(strlen(sha1_tests[i].message) == len*2);
+      assert(strlen(sha1_tests[i].digest) == 20 * 2);
+      for (h=0; h < len; ++h) {
+         char v[3];
+         v[0] = sha1_tests[i].message[h*2];
+         v[1] = sha1_tests[i].message[h*2+1];
+         v[2] = 0;
+         buffer[h] = (unsigned char) strtol(v, NULL, 16);
+      }
+      stb_sha1(digest, buffer, len);
+      for (h=0; h < 20; ++h) {
+         char v[3];
+         int res;
+         v[0] = sha1_tests[i].digest[h*2];
+         v[1] = sha1_tests[i].digest[h*2+1];
+         v[2] = 0;
+         res = digest[h] == strtol(v, NULL, 16);
+         c(res, sha1_tests[i].digest);
+         if (!res)
+            break;
+      }
+      {
+         int z;
+         FILE *f = fopen("data/test.bin", "wb");
+         if (!f) stb_fatal("Couldn't write to test.bin");
+         fwrite(buffer, len, 1, f);
+         fclose(f);
+         #ifdef _WIN32
+         z = stb_sha1_file(fdig, "data/test.bin");
+         if (!z) stb_fatal("Couldn't digest test.bin");
+         c(memcmp(digest, fdig, 20)==0, "stb_sh1_file");
+         #endif
+      }
+   }
+}
+
+
+#if 0
+
+stb__obj zero, one;
+
+void test_packed_floats(void)
+{
+   stb__obj *p;
+   float x,y,*q;
+   clock_t a,b,c;
+   int i;
+   stb_float_init();
+   for (i=-10; i < 10; ++i) {
+      float f = (float) pow(10,i);
+      float g = f * 10;
+      float delta = (g - f) / 10000;
+      while (f < g) {
+         stb__obj z = stb_float(f);
+         float k = stb_getfloat(z);
+         float p = stb_getfloat_table(z);
+         assert((z & 1) == 1);
+         assert(f == k);
+         assert(k == p);
+         f += delta;
+      }
+   }
+
+   zero = stb_float(0);
+   one  = stb_float(1);
+
+   p = malloc(8192 * 4);
+   for (i=0; i < 8192; ++i)
+      p[i] = stb_rand();
+   for (i=0; i < 8192; ++i)
+      if ((stb_rand() & 31) < 28)
+         p[i] = zero;
+
+   q = malloc(4 * 1024);
+      
+   a = clock();
+
+   x = y = 0;
+   for (i=0; i < 200000000; ++i)
+      q[i&1023] = stb_getfloat_table(p[i&8191]);
+   b = clock();
+   for (i=0; i < 200000000; ++i)
+      q[i&1023] = stb_getfloat_table2(p[i&8191]);
+   c = clock();
+   free(p);
+
+   free(q);
+
+   printf("Table: %d\nIFs: %d\n", b-a, c-b);
+}
+#endif
+
+
+void do_compressor(int argc,char**argv)
+{
+   char *p;
+   int len;
+
+   int window;
+   if (argc == 2) {
+      p = stb_file(argv[1], &len);
+      if (p) {
+         int dlen, clen = stb_compress_tofile("data/dummy.bin", p, len);
+         char *q = stb_decompress_fromfile("data/dummy.bin", &dlen);
+
+         if (len != dlen) {
+            printf("FAILED %d -> %d\n", len, clen);
+         } else {
+            int z = memcmp(q,p,dlen);
+            if (z != 0) 
+               printf("FAILED %d -> %d\n", len, clen);
+            else
+               printf("%d -> %d\n", len, clen);
+         }
+      }
+      return;
+   }
+
+   window = atoi(argv[1]);
+   if (window && argc == 4) {
+      p = stb_file(argv[3], &len);
+      if (p) {
+         stb_compress_hashsize(window);
+         stb_compress_tofile(argv[2], p, len);
+      }
+   } else if (argc == 3) {
+      p = stb_decompress_fromfile(argv[2], &len);
+      if (p) {
+         FILE *f = fopen(argv[1], "wb");
+         fwrite(p,1,len,f);
+         fclose(f);
+      } else {
+         fprintf(stderr, "FAILED.\n");
+      }
+   } else {
+      fprintf(stderr, "Usage: stb <hashsize> <output> <filetocompress>\n"
+                      "   or  stb            <output> <filetodecompress>\n");
+   }
+}
+
+#if 0
+// naive backtracking implementation
+int wildmatch(char *expr, char *candidate)
+{
+   while(*expr) {
+      if (*expr == '?') {
+         if (!*candidate) return 0;
+         ++candidate;
+         ++expr;
+      } else if (*expr == '*') {
+         ++expr;
+         while (*expr == '*' || *expr =='?') ++expr;
+         // '*' at end of expression matches anything
+         if (!*expr) return 1;
+         // now scan candidate 'til first match
+         while (*candidate) {
+            if (*candidate == *expr) {
+               // check this candidate
+               if (stb_wildmatch(expr+1, candidate+1))
+                  return 1;
+               // if not, then backtrack
+            }
+            ++candidate;
+         }
+      } else {
+         if (*expr != *candidate)
+            return 0;
+         ++expr, ++candidate;
+      }
+   }
+   return *candidate != 0;
+}
+
+int stb_matcher_find_slow(stb_matcher *m, char *str)
+{
+   int result = 1;
+   int i,j,y,z;
+   uint16 *previous = NULL;
+   uint16 *current = NULL;
+   uint16 *temp;
+
+   stb_arr_setsize(previous, 4);
+   stb_arr_setsize(current, 4);
+
+   previous = stb__add_if_inactive(m, previous, m->start_node);
+   previous = stb__eps_closure(m,previous);
+   if (stb__clear_goalcheck(m, previous))
+      goto done;
+
+   while (*str) {
+      y = stb_arr_len(previous);
+      for (i=0; i < y; ++i) {
+         stb_nfa_node *n = &m->nodes[previous[i]];
+         z = stb_arr_len(n->out);
+         for (j=0; j < z; ++j) {
+            if (n->out[j].match == *str)
+               current = stb__add_if_inactive(m, current, n->out[j].node);
+            else if (n->out[j].match == -1) {
+               if (*str != '\n')
+                  current = stb__add_if_inactive(m, current, n->out[j].node);
+            } else if (n->out[j].match < -1) {
+               int z = -n->out[j].match - 2;
+               if (m->charset[(uint8) *str] & (1 << z))
+                  current = stb__add_if_inactive(m, current, n->out[j].node);
+            }
+         }
+      }
+      ++str;
+      stb_arr_setlen(previous, 0);
+
+      temp = previous;
+      previous = current;
+      current = temp;
+
+      if (!m->match_start)
+         previous = stb__add_if_inactive(m, previous, m->start_node);
+      previous = stb__eps_closure(m,previous);
+      if (stb__clear_goalcheck(m, previous))
+         goto done;
+   }
+
+   result=0;
+
+done:
+   stb_arr_free(previous);
+   stb_arr_free(current);
+
+   return result;
+}
+#endif
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////
+//
+//   stb_parser
+//
+//   Generates an LR(1) parser from a grammar, and can parse with it
+
+
+
+// Symbol representations
+//
+// Client:     Internal:
+//    -           c=0     e aka epsilon
+//    -           c=1     $ aka end of string
+//   > 0        2<=c<M    terminals (note these are remapped from a sparse layout)
+//   < 0        M<=c<N    non-terminals
+
+#define END 1
+#define EPS 0
+
+short encode_term[4096];  // @TODO: malloc these
+short encode_nonterm[4096];
+int first_nonterm, num_symbols, symset;
+#define encode_term(x)     encode_term[x]
+#define encode_nonterm(x)  encode_nonterm[~(x)]
+#define encode_symbol(x)   ((x) >= 0 ? encode_term(x) : encode_nonterm(x))
+
+stb_bitset **compute_first(short ** productions)
+{
+   int i, changed;
+   stb_bitset **first = malloc(sizeof(*first) * num_symbols);
+
+   assert(symset);
+   for (i=0; i < num_symbols; ++i)
+      first[i] = stb_bitset_new(0, symset);
+
+   for (i=END; i < first_nonterm; ++i)
+      stb_bitset_setbit(first[i], i);
+
+   for (i=0; i < stb_arr_len(productions); ++i) {
+      if (productions[i][2] == 0) {
+         int nt = encode_nonterm(productions[i][0]);
+         stb_bitset_setbit(first[nt], EPS);
+      }
+   }
+
+   do {
+      changed = 0;
+      for (i=0; i < stb_arr_len(productions); ++i) {
+         int j, nt = encode_nonterm(productions[i][0]);
+         for (j=2; productions[i][j]; ++j) {
+            int z = encode_symbol(productions[i][j]);
+            changed |= stb_bitset_unioneq_changed(first[nt], first[z], symset);
+            if (!stb_bitset_testbit(first[z], EPS))
+               break;
+         }
+         if (!productions[i][j] && !stb_bitset_testbit(first[nt], EPS)) {
+            stb_bitset_setbit(first[nt], EPS);
+            changed = 1;
+         }
+      }
+   } while (changed);
+   return first;
+}
+
+stb_bitset **compute_follow(short ** productions, stb_bitset **first, int start)
+{
+   int i,j,changed;
+   stb_bitset **follow = malloc(sizeof(*follow) * num_symbols);
+
+   assert(symset);
+   for (i=0; i < num_symbols; ++i)
+      follow[i] = (i >= first_nonterm ? stb_bitset_new(0, symset) : NULL);
+
+   stb_bitset_setbit(follow[start], END);
+   do {
+      changed = 0;
+      for (i=0; i < stb_arr_len(productions); ++i) {
+         int nt = encode_nonterm(productions[i][0]);
+         for (j=2; productions[i][j]; ++j) {
+            if (productions[i][j] < 0) {
+               int k,z = encode_nonterm(productions[i][j]);
+               for (k=j+1; productions[i][k]; ++k) {
+                  int q = encode_symbol(productions[i][k]);
+                  changed |= stb_bitset_unioneq_changed(follow[z], first[q], symset);
+                  if (!stb_bitset_testbit(first[q], EPS))
+                     break;
+               }
+               if (!productions[i][k] == 0)
+                  changed |= stb_bitset_unioneq_changed(follow[z], follow[nt], symset);
+            }
+         }
+      }
+   } while (changed);
+
+   for (i=first_nonterm; i < num_symbols; ++i)
+      stb_bitset_clearbit(follow[i], EPS);
+
+   return follow;
+}
+
+void first_for_prod_plus_sym(stb_bitset **first, stb_bitset *out, short *prod, int symbol)
+{
+   stb_bitset_clearall(out, symset);
+   for(;*prod;++prod) {
+      int z = encode_symbol(*prod);
+      stb_bitset_unioneq_changed(out, first[z], symset);
+      if (!stb_bitset_testbit(first[z], EPS))
+         return;
+   }
+   stb_bitset_unioneq_changed(out, first[symbol], symset);
+}
+
+#define Item(p,c,t)       ((void *) (((t) << 18) + ((c) << 12) + ((p) << 2)))
+#define ItemProd(i)       ((((uint32) (i)) >> 2) & 1023)
+#define ItemCursor(i)     ((((uint32) (i)) >> 12) & 63)
+#define ItemLookahead(i)  (((uint32) (i)) >> 18)
+
+static void pc(stb_ps *p)
+{
+}
+
+typedef struct
+{
+   short *prod;
+   int prod_num;
+} ProdRef;
+
+typedef struct
+{
+   stb_bitset **first;
+   stb_bitset **follow;
+   short **   prod;
+   ProdRef ** prod_by_nt;
+} Grammar;
+
+stb_ps *itemset_closure(Grammar g, stb_ps *set)
+{
+   stb_bitset *lookahead;
+   int changed,i,j,k, list_len;
+   if (set == NULL) return set;
+   lookahead = stb_bitset_new(0, symset);
+   do {
+      void **list = stb_ps_getlist(set, &list_len);
+      changed = 0;
+      for (i=0; i < list_len; ++i) {
+         ProdRef *prod;
+         int nt, *looklist;
+         int p = ItemProd(list[i]), c = ItemCursor(list[i]), t = ItemLookahead(list[i]);
+         if (g.prod[p][c] >= 0) continue;
+         nt = encode_nonterm(g.prod[p][c]);
+         first_for_prod_plus_sym(g.first, lookahead, g.prod[p]+c+1, t);
+         looklist = stb_bitset_getlist(lookahead, 1, first_nonterm);
+               
+         prod = g.prod_by_nt[nt];
+         for (j=0; j < stb_arr_len(prod); ++j) {
+            assert(prod[j].prod[0] == g.prod[p][c]);
+            // matched production; now iterate terminals
+            for (k=0; k < stb_arr_len(looklist); ++k) {
+               void *item = Item(prod[j].prod_num,2,looklist[k]);
+               if (!stb_ps_find(set, item)) {
+                  changed = 1;
+                  set = stb_ps_add(set, item);
+                  pc(set);
+               }
+            }
+         }
+         stb_arr_free(looklist);
+      }
+      free(list);
+   } while (changed);
+   free(lookahead);
+   return set;
+}
+
+stb_ps *itemset_goto(Grammar g, stb_ps *set, int sym)
+{
+   int i, listlen;
+   void **list = stb_ps_fastlist(set, &listlen);
+   stb_ps *out = NULL;
+   for (i=0; i < listlen; ++i) {
+      int p,c;
+      if (!stb_ps_fastlist_valid(list[i])) continue;
+      p = ItemProd(list[i]), c = ItemCursor(list[i]);
+      if (encode_symbol(g.prod[p][c]) == sym) {
+         void *z = Item(p,c+1,ItemLookahead(list[i]));
+         if (!stb_ps_find(out, z))
+            out = stb_ps_add(out, z);
+         pc(out);
+      }
+   }
+   return itemset_closure(g, out);
+}
+
+void itemset_all_nextsym(Grammar g, stb_bitset *out, stb_ps *set)
+{
+   int i, listlen;
+   void **list = stb_ps_fastlist(set, &listlen);
+   stb_bitset_clearall(out, symset);
+   pc(set);
+   for (i=0; i < listlen; ++i) {
+      if (stb_ps_fastlist_valid(list[i])) {
+         int p = ItemProd(list[i]);
+         int c = ItemCursor(list[i]);
+         if (g.prod[p][c])
+            stb_bitset_setbit(out, encode_symbol(g.prod[p][c]));
+      }
+   }
+}
+
+stb_ps ** generate_items(Grammar g, int start_prod)
+{
+   stb_ps ** all=NULL;
+   int i,j,k;
+   stb_bitset *try = stb_bitset_new(0,symset);
+   stb_ps *set = NULL;
+   void *item = Item(start_prod, 2, END);
+   set = stb_ps_add(set, item);
+   pc(set);
+   set = itemset_closure(g, set);
+   pc(set);
+   stb_arr_push(all, set);
+   for (i = 0; i < stb_arr_len(all); ++i) {
+      // only try symbols that appear in all[i]... there's a smarter way to do this,
+      // which is to take all[i], and divide it up by symbol
+      pc(all[i]);
+      itemset_all_nextsym(g, try, all[i]);
+      for (j = 1; j < num_symbols; ++j) {
+         if (stb_bitset_testbit(try, j)) {
+            stb_ps *out;
+            if (stb_arr_len(all) > 4) pc(all[4]);
+            if (i == 1 && j == 29) {
+               if (stb_arr_len(all) > 4) pc(all[4]);
+               out = itemset_goto(g, all[i], j);
+               if (stb_arr_len(all) > 4) pc(all[4]);
+            } else
+               out = itemset_goto(g, all[i], j);
+            pc(out);
+            if (stb_arr_len(all) > 4) pc(all[4]);
+            if (out != NULL) {
+               // add it to the array if it's not already there
+               for (k=0; k < stb_arr_len(all); ++k)
+                  if (stb_ps_eq(all[k], out))
+                     break;
+               if (k == stb_arr_len(all)) {
+                  stb_arr_push(all, out);
+                  pc(out);
+                  if (stb_arr_len(all) > 4) pc(all[4]);
+               } else
+                  stb_ps_delete(out);
+            }
+         }
+      }
+   }
+   free(try);
+   return all;
+}
+
+typedef struct
+{
+   int num_stack;
+   int function;
+} Reduction;
+
+typedef struct
+{
+   short *encode_term;
+   Reduction *reductions;
+   short **action_goto; // terminals are action, nonterminals are goto
+   int start;
+   int end_term;
+} Parser;
+
+enum
+{
+   A_error, A_accept, A_shift, A_reduce, A_conflict
+};
+
+typedef struct
+{
+   uint8 type;
+   uint8 cursor;
+   short prod;
+   short value;
+} Action;
+
+Parser *parser_create(short **productions, int num_prod, int start_nt, int end_term)
+{
+   short *mini_rule = malloc(4 * sizeof(mini_rule[0]));
+   Action *actions;
+   Grammar g;
+   stb_ps ** sets;
+   Parser *p = malloc(sizeof(*p));
+   int i,j,n;
+   stb_bitset *mapped;
+   int min_s=0, max_s=0, termset, ntset, num_states, num_reductions, init_prod;
+
+   int synth_start;
+
+   // remap sparse terminals and nonterminals
+
+   for (i=0; i < num_prod; ++i) {
+      for (j=2; productions[i][j]; ++j) {
+         if (productions[i][j] < min_s) min_s = productions[i][j];
+         if (productions[i][j] > max_s) max_s = productions[i][j];
+      }
+   }
+   synth_start = --min_s;
+
+   termset = (max_s + 32) >> 5;
+   ntset = (~min_s + 32) >> 5;
+   memset(encode_term, 0, sizeof(encode_term));
+   memset(encode_nonterm, 0, sizeof(encode_nonterm));
+
+   mapped = stb_bitset_new(0, termset);
+   n = 2;
+   for (i=0; i < num_prod; ++i)
+      for (j=2; productions[i][j]; ++j)
+         if (productions[i][j] > 0)
+            if (!stb_bitset_testbit(mapped, productions[i][j])) {
+               stb_bitset_setbit(mapped, productions[i][j]);
+               encode_term[productions[i][j]] = n++;
+            }
+   free(mapped);
+
+   first_nonterm = n;
+
+   mapped = stb_bitset_new(0, ntset);
+   for (i=0; i < num_prod; ++i)
+      for (j=2; productions[i][j]; ++j)
+         if (productions[i][j] < 0)
+            if (!stb_bitset_testbit(mapped, ~productions[i][j])) {
+               stb_bitset_setbit(mapped, ~productions[i][j]);
+               encode_nonterm[~productions[i][j]] = n++;
+            }
+   free(mapped);
+
+   // add a special start state for internal processing
+   p->start = n++;
+   encode_nonterm[synth_start] = p->start;
+   mini_rule[0] = synth_start;
+   mini_rule[1] = -32768;
+   mini_rule[2] = start_nt;
+   mini_rule[3] = 0;
+
+   p->end_term = end_term;
+
+   num_symbols = n;
+   
+   // create tables
+   g.prod = NULL;
+   g.prod_by_nt = malloc(num_symbols * sizeof(g.prod_by_nt[0]));
+   for (i=0; i < num_symbols; ++i)
+      g.prod_by_nt[i] = NULL;
+
+   for (i=0; i < num_prod; ++i) {
+      stb_arr_push(g.prod, productions[i]);
+   }
+   init_prod = stb_arr_len(g.prod);
+   stb_arr_push(g.prod, mini_rule);
+
+   num_reductions = stb_arr_len(g.prod);
+   p->reductions = malloc(num_reductions * sizeof(*p->reductions));
+
+   symset = (num_symbols + 31) >> 5;
+   g.first = compute_first(g.prod);
+   g.follow = compute_follow(g.prod, g.first, p->start);
+
+   for (i=0; i < stb_arr_len(g.prod); ++i) {
+      ProdRef pr = { g.prod[i], i };
+      stb_arr_push(g.prod_by_nt[encode_nonterm(g.prod[i][0])], pr);
+   }
+
+   sets = generate_items(g, init_prod);
+
+   num_states = stb_arr_len(sets);
+   // now generate tables
+
+   actions = malloc(sizeof(*actions) * first_nonterm);
+   p->action_goto = (short **) stb_array_block_alloc(num_states, sizeof(short) * num_symbols);
+   for (i=0; i < num_states; ++i) {
+      int j,n;
+      void **list = stb_ps_getlist(sets[i], &n);
+      memset(actions, 0, sizeof(*actions) * first_nonterm);
+      for (j=0; j < n; ++j) {
+         int p = ItemProd(list[j]), c = ItemCursor(list[j]), t = ItemLookahead(list[j]);
+         if (g.prod[p][c] == 0) {
+            if (p == init_prod) {
+               // @TODO: check for conflicts
+               assert(actions[t].type == A_error || actions[t].type == A_accept);
+               actions[t].type = A_accept;
+            } else {
+               // reduce production p
+               if (actions[t].type == A_reduce) {
+                  // is it the same reduction we already have?
+                  if (actions[t].prod != p) {
+                     // no, it's a reduce-reduce conflict!
+                     printf("Reduce-reduce conflict for rule %d and %d, lookahead %d\n", p, actions[t].prod, t);
+                     // @TODO: use precedence
+                     actions[t].type = A_conflict;
+                  }
+               } else if (actions[t].type == A_shift) {
+                  printf("Shift-reduce conflict for rule %d and %d, lookahead %d\n", actions[t].prod, p, t);
+                  actions[t].type = A_conflict;
+               } else if (actions[t].type == A_accept) {
+                  assert(0);
+               } else if (actions[t].type == A_error) {
+                  actions[t].type = A_reduce;
+                  actions[t].prod = p;
+               }
+            }
+         } else if (g.prod[p][c] > 0) {
+            int a = encode_symbol(g.prod[p][c]), k;
+            stb_ps *out = itemset_goto(g, sets[i], a);
+            for (k=0; k < stb_arr_len(sets); ++k)
+               if (stb_ps_eq(sets[k], out))
+                  break;
+            assert(k < stb_arr_len(sets));
+            // shift k
+            if (actions[a].type == A_shift) {
+               if (actions[a].value != k) {
+                  printf("Shift-shift conflict! Rule %d and %d with lookahead %d/%d\n", actions[a].prod, p, a,t);
+                  actions[a].type = A_conflict;
+               }
+            } else if (actions[a].type == A_reduce) {
+               printf("Shift-reduce conflict for rule %d and %d, lookahead %d/%d\n", p, actions[a].prod, a,t);
+               actions[a].type = A_conflict;
+            } else if (actions[a].type == A_accept) {
+               assert(0);
+            } else if (actions[a].type == A_error) {
+               actions[a].type = A_shift;
+               actions[a].prod = p;
+               actions[a].cursor = c;
+               actions[a].value  = k;
+            }
+         }
+      }
+      // @TODO: recompile actions into p->action_goto
+   }
+
+   free(mini_rule);
+   stb_pointer_array_free(g.first , num_symbols); free(g.first );
+   stb_pointer_array_free(g.follow, num_symbols); free(g.follow);
+   stb_arr_free(g.prod);
+   for (i=0; i < num_symbols; ++i)
+      stb_arr_free(g.prod_by_nt[i]);
+   free(g.prod_by_nt);
+   for (i=0; i < stb_arr_len(sets); ++i)
+      stb_ps_delete(sets[i]);
+   stb_arr_free(sets);
+
+   return p;
+}
+
+void parser_destroy(Parser *p)
+{
+   free(p);
+}
+
+#if 0
+enum nonterm
+{
+   N_globals = -50,
+   N_global, N_vardef, N_varinitlist, N_varinit, N_funcdef, N_optid, N_optparamlist,
+   N_paramlist, N_param, N_optinit, N_optcomma, N_statements, N_statement,
+   N_optexpr, N_assign, N_if, N_ifcore, N_else, N_dictdef, N_dictdef2,
+   N_dictdefitem, N_expr,
+   N__last
+};
+
+short grammar[][10] =
+{
+   { N_globals    ,  0, N_globals, N_global                                 },
+   { N_globals    ,  0                                                      },
+   { N_global     ,  0, N_vardef                                            },
+   { N_global     ,  0, N_funcdef                                           },
+   { N_vardef     ,  0, ST_var, N_varinitlist,                               },
+   { N_varinitlist,  0, N_varinitlist, ',', N_varinit                       },
+   { N_varinitlist,  0, N_varinit,                                          },
+   { N_varinit    ,  0, ST_id, N_optinit,                                    },
+   { N_funcdef    ,  0, ST_func, N_optid, '(', N_optparamlist, ')', N_statements, ST_end },
+   { N_optid      ,  0, ST_id                                                },
+   { N_optid      ,  0,                                                     },
+   { N_optparamlist, 0,                                                     },
+   { N_optparamlist, 0, N_paramlist, N_optcomma                             },
+   { N_paramlist  ,  0, N_paramlist, ',', N_param                           },
+   { N_paramlist  ,  0, N_param                                             },
+   { N_param      ,  0, ST_id, N_optinit                                     },
+   { N_optinit    ,  0, '=', N_expr                                         },
+   { N_optinit    ,  0,                                                     },
+   { N_optcomma   ,  0, ','                                                 },
+   { N_optcomma   ,  0,                                                     },
+   { N_statements ,  0, N_statements, N_statement                           },
+   { N_statement  ,  0, N_statement, ';'                                    },
+   { N_statement  ,  0, N_varinit                                           },
+   { N_statement  ,  0, ST_return, N_expr                                    },
+   { N_statement  ,  0, ST_break , N_optexpr                                 },
+   { N_optexpr    ,  0, N_expr                                              },
+   { N_optexpr    ,  0,                                                     },
+   { N_statement  ,  0, ST_continue                                          },
+   { N_statement  ,  0, N_assign                                            },
+   { N_assign     ,  0, N_expr, '=', N_assign                               },
+   //{ N_assign     ,  0, N_expr                                              },
+   { N_statement  ,  0, ST_while, N_expr, N_statements, ST_end                },
+   { N_statement  ,  0, ST_if, N_if,                                         },
+   { N_if         ,  0, N_ifcore, ST_end,                                    },
+   { N_ifcore     ,  0, N_expr, ST_then, N_statements, N_else, ST_end         },
+   { N_else       ,  0, ST_elseif, N_ifcore                                  },
+   { N_else       ,  0, ST_else, N_statements                                },
+   { N_else       ,  0,                                                     },
+   { N_dictdef    ,  0, N_dictdef2, N_optcomma                              },
+   { N_dictdef2   ,  0, N_dictdef2, ',', N_dictdefitem                      },
+   { N_dictdef2   ,  0, N_dictdefitem                                       },
+   { N_dictdefitem,  0, ST_id, '=', N_expr                                   },
+   { N_dictdefitem,  0, N_expr                                              },
+   { N_expr       ,  0, ST_number                                            },
+   { N_expr       ,  0, ST_string                                            },
+   { N_expr       ,  0, ST_id                                                },
+   { N_expr       ,  0, N_funcdef                                           },
+   { N_expr       ,  0, '-', N_expr                                         },
+   { N_expr       ,  0, '{', N_dictdef, '}'                                 },
+   { N_expr       ,  0, '(', N_expr, ')'                                    },
+   { N_expr       ,  0, N_expr, '.', ST_id                                   },
+   { N_expr       ,  0, N_expr, '[', N_expr, ']'                            },
+   { N_expr       ,  0, N_expr, '(', N_dictdef, ')'                         },
+#if 0
+#define BINOP(op)  { N_expr, 0, N_expr, op, N_expr }
+   BINOP(ST_and), BINOP(ST_or), BINOP(ST_eq), BINOP(ST_ne),
+   BINOP(ST_le),  BINOP(ST_ge), BINOP('>') , BINOP('<' ),
+   BINOP('&'), BINOP('|'), BINOP('^'), BINOP('+'), BINOP('-'),
+   BINOP('*'), BINOP('/'), BINOP('%'),
+#undef BINOP
+#endif
+};
+
+short *grammar_list[stb_arrcount(grammar)];
+
+void test_parser_generator(void)
+{
+   Parser *p;
+   int i;
+   assert(N__last <= 0);
+   for (i=0; i < stb_arrcount(grammar); ++i)
+      grammar_list[i] = grammar[i];
+   p = parser_create(grammar_list, stb_arrcount(grammar), N_globals, 0);
+   parser_destroy(p);
+}
+#endif
+
+
+#if 0
+// stb_threadtest.c
+
+
+#include <windows.h>
+#define STB_DEFINE
+//#define STB_THREAD_TEST
+#include "../stb.h"
+
+#define NUM_WORK 100
+
+void *work_consumer(void *p)
+{
+   stb__thread_sleep(20);
+   return NULL;
+}
+
+int pass;
+stb_threadqueue *tq1, *tq2, *tq3, *tq4;
+volatile float t1,t2;
+
+//    with windows.h
+// Worked correctly with 100,000,000 enqueue/dequeue WAITLESS
+// (770 passes, 170000 per pass)
+// Worked correctly with   2,500,000 enqueue/dequeue !WAITLESS
+// (15 passes, 170000 per pass)
+// Worked correctly with   1,500,000 enqueue/dequeue WAITLESS && STB_THREAD_TEST
+// (9 passes, 170000 per pass)
+//    without windows.h
+// Worked correctly with   1,000,000 enqueue/dequeue WAITLESS && STB_THREAD_TEST
+// (6 passes, 170000 per pass)
+// Worked correctly with     500,000 enqueue/dequeue !WAITLESS && STB_THREAD_TEST
+// (3 passes, 170000 per pass)
+// Worked correctly with   1,000,000 enqueue/dequeue WAITLESS
+// (15 passes, 170000 per pass)
+#define WAITLESS
+
+volatile int table[1000*1000*10];
+
+void wait(int n)
+{
+#ifndef WAITLESS
+   int j;
+   float y;
+   for (j=0; j < n; ++j)
+      y += 1 / (t1+j);
+   t2 = y;
+#endif
+}
+
+void *tq1_consumer(void *p)
+{
+   for(;;) {
+      int z;
+      float y = 0;
+      stb_threadq_get_block(tq1, &z);
+      wait(5000);
+      table[z] = pass;
+   }
+}
+
+void *tq2_consumer(void *p)
+{
+   for(;;) {
+      int z;
+      if (stb_threadq_get(tq2, &z))
+         table[z] = pass;
+      wait(1000);
+   }
+}
+
+void *tq3_consumer(void *p)
+{
+   for(;;) {
+      int z;
+      stb_threadq_get_block(tq3, &z);
+      table[z] = pass;
+      wait(500);
+   }
+}
+
+void *tq4_consumer(void *p)
+{
+   for (;;) {
+      int z;
+      stb_threadq_get_block(tq4, &z);
+      table[z] = pass;
+      wait(500);
+   }
+}
+
+typedef struct
+{
+   int start, end;
+   stb_threadqueue *tq;
+   int delay;
+} write_data;
+
+void *writer(void *q)
+{
+   int i;
+   write_data *p = (write_data *) q;
+   for (i=p->start; i < p->end; ++i) {
+      stb_threadq_add_block(p->tq, &i);
+      #ifndef WAITLESS
+      if (p->delay) stb__thread_sleep(p->delay);
+      else {
+         int j;
+         float z = 0;
+         for (j=0; j <= 20; ++j)
+            z += 1 / (t1+j);
+         t2 = z;
+      }
+      #endif
+   }
+   return NULL;
+}
+
+write_data info[256];
+int pos;
+
+void start_writer(int z, int count, stb_threadqueue *tq, int delay)
+{
+   info[z].start = pos;
+   info[z].end = pos+count;
+   info[z].tq = tq;
+   info[z].delay = delay;
+   stb_create_thread(writer, &info[z]);
+   pos += count;
+}
+
+int main(int argc, char **argv)
+{
+   int i;
+   stb_sync s = stb_sync_new();
+   stb_sync_set_target(s, NUM_WORK+1);
+   stb_work_numthreads(2);
+   for (i=0; i < NUM_WORK; ++i) {
+      stb_work_reach(work_consumer, NULL, NULL, s);
+   }
+   printf("Started stb_work test.\n");
+
+   t1 = 1;
+
+   // create the queues
+   tq1 = stb_threadq_new(4, 4, TRUE , TRUE);
+   tq2 = stb_threadq_new(4, 4, TRUE , FALSE);
+   tq3 = stb_threadq_new(4, 4, FALSE, TRUE);
+   tq4 = stb_threadq_new(4, 4, FALSE, FALSE);
+
+   // start the consumers
+   stb_create_thread(tq1_consumer, NULL);
+   stb_create_thread(tq1_consumer, NULL);
+   stb_create_thread(tq1_consumer, NULL);
+
+   stb_create_thread(tq2_consumer, NULL);
+
+   stb_create_thread(tq3_consumer, NULL);
+   stb_create_thread(tq3_consumer, NULL);
+   stb_create_thread(tq3_consumer, NULL);
+   stb_create_thread(tq3_consumer, NULL);
+   stb_create_thread(tq3_consumer, NULL);
+   stb_create_thread(tq3_consumer, NULL);
+   stb_create_thread(tq3_consumer, NULL);
+
+   stb_create_thread(tq4_consumer, NULL);
+
+   for (pass=1; pass <= 5000; ++pass) {
+      int z = 0;
+      int last_n = -1;
+      int identical = 0;
+      pos = 0;
+      start_writer(z++, 50000, tq1, 0);
+      start_writer(z++, 50000, tq1, 0);
+      start_writer(z++, 50000, tq1, 0);
+
+      start_writer(z++, 5000, tq2, 1);
+      start_writer(z++, 3000, tq2, 3);
+      start_writer(z++, 2000, tq2, 5);
+
+      start_writer(z++, 5000, tq3, 3);
+
+      start_writer(z++, 5000, tq4, 3);
+      #ifndef WAITLESS
+      stb__thread_sleep(8000);
+      #endif
+      for(;;) {
+         int n =0;
+         for (i=0; i < pos; ++i) {
+            if (table[i] == pass)
+               ++n;
+         }
+         if (n == pos) break;
+         if (n == last_n) {
+            ++identical;
+            if (identical == 3) {
+               printf("Problem slots:\n");
+               for (i=0; i < pos; ++i) {
+                  if (table[i] != pass) printf("%d ", i);
+               }
+               printf("\n");
+            } else {
+               if (identical < 3)
+                  printf("Processed %d of %d\n", n, pos);
+               else
+                  printf(".");
+            }
+         } else {
+            identical = 0;
+            printf("Processed %d of %d\n", n, pos);
+         }
+         last_n = n;
+         #ifdef WAITLESS
+         stb__thread_sleep(750);
+         #else
+         stb__thread_sleep(3000);
+         #endif
+      }
+      printf("Finished pass %d\n", pass);
+   }
+
+   stb_sync_reach_and_wait(s);
+   printf("stb_work test completed ok.\n");
+   return 0;
+}
+#endif
+
+
+#if 0
+//////////////////////////////////////////////////////////////////////////////
+//
+//   collapse tree leaves up to parents until we only have N nodes
+//   useful for cmirror summaries
+
+typedef struct stb_summary_tree
+{
+   struct stb_summary_tree **children;
+   int num_children;
+   float weight;
+} stb_summary_tree;
+
+STB_EXTERN void *stb_summarize_tree(void *tree, int limit, float reweight);
+
+#ifdef STB_DEFINE
+
+typedef struct stb_summary_tree2
+{
+   STB__ARR(struct stb_summary_tree2 *) children;
+   int num_children;
+   float weight;
+   float weight_with_all_children;
+   float makes_target_weight;
+   float weight_at_target;
+   stb_summary_tree *original;
+   struct stb_summary_tree2 *target;
+   STB__ARR(struct stb_summary_tree2 *) targeters;
+} stb_summary_tree2;
+
+static stb_summary_tree2 *stb__summarize_clone(stb_summary_tree *t)
+{
+   int i;
+   stb_summary_tree2 *s;
+   s = (stb_summary_tree2 *) malloc(sizeof(*s));
+   s->original = t;
+   s->weight = t->weight;
+   s->weight_with_all_children = 0;
+   s->weight_at_target = 0;
+   s->target = NULL;
+   s->targeters = NULL;
+   s->num_children = t->num_children;
+   s->children = NULL;
+   for (i=0; i < s->num_children; ++i)
+      stb_arr_push(s->children, stb__summarize_clone(t->children[i]));
+   return s;
+}
+
+static float stb__summarize_compute_targets(stb_summary_tree2 *parent, stb_summary_tree2 *node, float reweight, float weight)
+{
+   float total = 0;
+   if (node->weight == 0 && node->num_children == 1 && parent) {
+      node->target = parent;
+      return stb__summarize_compute_targets(parent, node->children[0], reweight, weight*reweight);
+   } else {
+      float total=0;
+      int i;
+      for (i=0; i < node->num_children; ++i)
+         total += stb__summarize_compute_targets(node, node->children[i], reweight, reweight);
+      node->weight_with_all_children = total + node->weight;
+      if (parent && node->weight_with_all_children) {
+         node->target = parent;
+         node->weight_at_target = node->weight_with_all_children * weight;
+         node->makes_target_weight = node->weight_at_target + parent->weight;
+         stb_arr_push(parent->targeters, node);
+      } else {
+         node->target = NULL;
+         node->weight_at_target = node->weight;
+         node->makes_target_weight = 0;
+      }
+      return node->weight_with_all_children * weight;
+   }      
+}
+
+static stb_summary_tree2 ** stb__summarize_make_array(STB__ARR(stb_summary_tree2 *) all, stb_summary_tree2 *tree)
+{
+   int i;
+   stb_arr_push(all, tree);
+   for (i=0; i < tree->num_children; ++i)
+      all = stb__summarize_make_array(all, tree->children[i]);
+   return all;
+}
+
+typedef stb_summary_tree2 * stb__stree2;
+stb_define_sort(stb__summarysort, stb__stree2, (*a)->makes_target_weight < (*b)->makes_target_weight)
+
+void *stb_summarize_tree(void *tree, int limit, float reweight)
+{
+   int i,j,k;
+   STB__ARR(stb_summary_tree *) ret=NULL;
+   STB__ARR(stb_summary_tree2 *) all=NULL;
+
+   // first clone the tree so we can manipulate it
+   stb_summary_tree2 *t = stb__summarize_clone((stb_summary_tree *) tree);
+   if (reweight < 1) reweight = 1;
+
+   // now compute how far up the tree each node would get pushed
+   // there's no value in pushing a node up to an empty node with
+   // only one child, so we keep pushing it up
+   stb__summarize_compute_targets(NULL, t, reweight, 1);
+
+   all = stb__summarize_make_array(all, t);
+
+   // now we want to iteratively find the smallest 'makes_target_weight',
+   // update that, and then fix all the others (which will be all descendents)
+   // to do this efficiently, we need a heap or a sorted binary tree
+   // what we have is an array. maybe we can insertion sort the array?
+   stb__summarysort(all, stb_arr_len(all));
+
+   for (i=0; i < stb_arr_len(all) - limit; ++i) {
+      stb_summary_tree2 *src, *dest;
+      src = all[i];
+      dest = all[i]->target;
+      if (src->makes_target_weight == 0) continue;
+      assert(dest != NULL);
+
+      for (k=0; k < stb_arr_len(all); ++k)
+         if (all[k] == dest)
+            break;
+      assert(k != stb_arr_len(all));
+      assert(i < k);
+
+      // move weight from all[i] to target
+      src->weight = dest->makes_target_weight;
+      src->weight = 0;
+      src->makes_target_weight = 0;
+      // recompute effect of other descendents
+      for (j=0; j < stb_arr_len(dest->targeters); ++j) {
+         if (dest->targeters[j]->weight) {
+            dest->targeters[j]->makes_target_weight = dest->weight + dest->targeters[j]->weight_at_target;
+            assert(dest->targeters[j]->makes_target_weight <= dest->weight_with_all_children);
+         }
+      }
+      STB_(stb__summarysort,_ins_sort)(all+i, stb_arr_len(all)-i);
+   }
+   // now the elements in [ i..stb_arr_len(all) ) are the relevant ones
+   for (; i < stb_arr_len(all); ++i)
+      stb_arr_push(ret, all[i]->original);
+
+   // now free all our temp data
+   for (i=0; i < stb_arr_len(all); ++i) {
+      stb_arr_free(all[i]->children);
+      free(all[i]);
+   }
+   stb_arr_free(all);
+   return ret;
+}
+#endif
+
+#endif