Merge branch 'incoming'

74 files changed, 7350 insertions, 1790 deletions

diff --git a/AUTHORS b/AUTHORS
index ea4c8f0b..d3cdd156 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -90,4 +90,6 @@ a license to everyone to use it as detailed in LICENSE.)
 * Soeren Balko <soeren.balko@gmail.com>
 * Ryan Kelly (ryan@rfk.id.au)
 * Michael Lelli <toadking@toadking.com>
+* Yu Kobayashi <yukoba@accelart.jp>
+* Pin Zhang <zhangpin04@gmail.com>
 
diff --git a/emcc b/emcc
index 91b109b6..8f71883d 100755
--- a/emcc
+++ b/emcc
@@ -53,6 +53,15 @@ from tools import shared, jsrun
 from tools.shared import Compression, execute, suffix, unsuffixed, unsuffixed_basename
 from tools.response_file import read_response_file
 
+CXX_SUFFIXES = ('.cpp', '.cxx', '.cc')
+SOURCE_SUFFIXES = ('.c', '.cpp', '.cxx', '.cc', '.m', '.mm')
+BITCODE_SUFFIXES = ('.bc', '.o', '.obj')
+DYNAMICLIB_SUFFIXES = ('.dylib', '.so', '.dll')
+STATICLIB_SUFFIXES = ('.a',)
+ASSEMBLY_SUFFIXES = ('.ll',)
+LIB_PREFIXES = ('', 'lib')
+JS_CONTAINING_SUFFIXES = ('js', 'html')
+
 # Mapping of emcc opt levels to llvm opt levels. We use llvm opt level 3 in emcc opt
 # levels 2 and 3 (emcc 3 is unsafe opts, so unsuitable for the only level to get
 # llvm opt level 3, and speed-wise emcc level 2 is already the slowest/most optimizing
@@ -532,7 +541,7 @@ if CONFIGURE_CONFIG or CMAKE_CONFIG:
         if debug_configure: open(tempout, 'a').write('============= ' + arg + '\n' + src + '\n=============\n\n')
       except:
         pass
-    if arg.endswith('.s'):
+    elif arg.endswith('.s'):
       if debug_configure: open(tempout, 'a').write('(compiling .s assembly, must use clang\n')
       use_js = 0
 
@@ -615,15 +624,6 @@ if EMMAKEN_CFLAGS: CC_ADDITIONAL_ARGS += shlex.split(EMMAKEN_CFLAGS)
 
 # ---------------- Utilities ---------------
 
-SOURCE_SUFFIXES = ('.c', '.cpp', '.cxx', '.cc', '.m', '.mm')
-BITCODE_SUFFIXES = ('.bc', '.o', '.obj')
-DYNAMICLIB_SUFFIXES = ('.dylib', '.so', '.dll')
-STATICLIB_SUFFIXES = ('.a',)
-ASSEMBLY_SUFFIXES = ('.ll',)
-LIB_PREFIXES = ('', 'lib')
-
-JS_CONTAINING_SUFFIXES = ('js', 'html')
-
 seen_names = {}
 def uniquename(name):
   if name not in seen_names:
@@ -787,6 +787,7 @@ try:
       newargs[i+1] = ''
     elif newargs[i].startswith('--minify'):
       check_bad_eq(newargs[i])
+      assert newargs[i+1] == '0', '0 is the only supported option for --minify; 1 has been deprecated'
       debug_level = max(1, debug_level)
       newargs[i] = ''
       newargs[i+1] = ''
@@ -1010,7 +1011,7 @@ try:
     logging.error('no input files\nnote that input files without a known suffix are ignored, make sure your input files end with one of: ' + str(SOURCE_SUFFIXES + BITCODE_SUFFIXES + DYNAMICLIB_SUFFIXES + STATICLIB_SUFFIXES + ASSEMBLY_SUFFIXES))
     exit(0)
 
-  newargs += CC_ADDITIONAL_ARGS
+  newargs = CC_ADDITIONAL_ARGS + newargs
 
   assert not (Compression.on and final_suffix != 'html'), 'Compression only works when generating HTML'
 
@@ -1030,6 +1031,10 @@ try:
     exec('shared.Settings.' + key + ' = ' + value)
 
   # Apply effects from settings
+  if bind and shared.Settings.ASM_JS:
+    logging.warning('disabling asm.js since embind is not ready for it yet')
+    shared.Settings.ASM_JS = 0
+
   if shared.Settings.ASM_JS:
     assert opt_level >= 1, 'asm.js requires -O1 or above'
 
@@ -1083,6 +1088,10 @@ try:
   if shared.Settings.DLOPEN_SUPPORT:
     shared.Settings.LINKABLE = 1
 
+  if shared.Settings.STB_IMAGE and final_suffix in JS_CONTAINING_SUFFIXES:
+    input_files.append(shared.path_from_root('third_party', 'stb_image.c'))
+    shared.Settings.EXPORTED_FUNCTIONS += ['_stbi_load', '_stbi_load_from_memory', '_stbi_image_free']
+
   ## Compile source code to bitcode
 
   logging.debug('compiling to bitcode')
@@ -1097,6 +1106,8 @@ try:
       output_file = in_temp(unsuffixed(uniquename(input_file)) + '.o')
       temp_files.append(output_file)
       args = newargs + ['-emit-llvm', '-c', input_file, '-o', output_file]
+      if input_file.endswith(CXX_SUFFIXES):
+        args += shared.EMSDK_CXX_OPTS
       logging.debug("running:" + call + ' ' + ' '.join(args))
       execute([call] + args) # let compiler frontend print directly, so colors are saved (PIPE kills that)
       if not os.path.exists(output_file):
diff --git a/emlink.py b/emlink.py
index 708c08d6..7311f84a 100644
--- a/emlink.py
+++ b/emlink.py
@@ -6,9 +6,9 @@ Fast static linker for emscripten outputs. Specifically this links asm.js module
 See https://github.com/kripken/emscripten/wiki/Linking
 '''
 
-import os, subprocess, sys, re
+import sys
 from tools import shared
-from tools import js_optimizer
+from tools.asm_module import AsmModule
 
 try:
   me, main, side, out = sys.argv[:4]
@@ -22,270 +22,6 @@ print 'Output:', out
 
 shared.try_delete(out)
 
-class AsmModule():
-  def __init__(self, filename):
-    self.filename = filename
-    self.js = open(filename).read()
-
-    self.start_asm = self.js.find(js_optimizer.start_asm_marker)
-    self.start_funcs = self.js.find(js_optimizer.start_funcs_marker)
-    self.end_funcs = self.js.rfind(js_optimizer.end_funcs_marker)
-    self.end_asm = self.js.rfind(js_optimizer.end_asm_marker)
-
-    # pre
-    self.pre_js = self.js[:self.start_asm]
-
-    # heap initializer
-    self.staticbump = int(re.search(shared.JS.memory_staticbump_pattern, self.pre_js).group(1))
-    if self.staticbump:
-      self.mem_init_js = re.search(shared.JS.memory_initializer_pattern, self.pre_js).group(0)
-
-    # global initializers
-    global_inits = re.search(shared.JS.global_initializers_pattern, self.pre_js)
-    if global_inits:
-      self.global_inits_js = global_inits.group(0)
-      self.global_inits = map(lambda init: init.split('{')[2][1:].split('(')[0], global_inits.groups(0)[0].split(','))
-    else:
-      self.global_inits_js = ''
-      self.global_inits = []
-
-    # imports (and global variables)
-    first_var = self.js.find('var ', self.js.find('var ', self.start_asm)+4)
-    self.pre_imports_js = self.js[self.start_asm:first_var]
-    self.imports_js = self.js[first_var:self.start_funcs]
-    self.imports = {}
-    for imp in js_optimizer.import_sig.finditer(self.imports_js):
-      key, value = imp.group(0).split('var ')[1][:-1].split('=', 1)
-      self.imports[key] = value
-    #print >> sys.stderr, 'imports', self.imports
-
-    # funcs
-    self.funcs_js = self.js[self.start_funcs:self.end_funcs]
-    self.funcs = set([m.group(2) for m in js_optimizer.func_sig.finditer(self.funcs_js)])
-    #print 'funcs', self.funcs
-
-    # tables and exports
-    post_js = self.js[self.end_funcs:self.end_asm]
-    ret = post_js.find('return')
-    self.tables_js = post_js[:ret]
-    self.exports_js = post_js[ret:]
-    self.tables = self.parse_tables(self.tables_js)
-    self.exports = set([export.strip() for export in self.exports_js[self.exports_js.find('{')+1:self.exports_js.find('}')].split(',')])
-
-    # post
-    self.post_js = self.js[self.end_asm:]
-    self.sendings = {}
-    for sending in [sending.strip() for sending in self.post_js[self.post_js.find('}, { ')+5:self.post_js.find(' }, buffer);')].split(',')]:
-      colon = sending.find(':')
-      self.sendings[sending[:colon].replace('"', '')] = sending[colon+1:].strip()
-    self.module_defs = set(re.findall('var [\w\d_$]+ = Module\["[\w\d_$]+"\] = asm\["[\w\d_$]+"\];\n', self.post_js))
-
-  def relocate_into(self, main):
-    # heap initializer
-    if self.staticbump > 0:
-      new_mem_init = self.mem_init_js[:self.mem_init_js.rfind(', ')] + ', Runtime.GLOBAL_BASE+%d)' % main.staticbump
-      main.pre_js = re.sub(shared.JS.memory_staticbump_pattern, 'STATICTOP = STATIC_BASE + %d;\n' % (main.staticbump + side.staticbump) + new_mem_init, main.pre_js, count=1)
-
-    # Find function name replacements TODO: do not rename duplicate names with duplicate contents, just merge them
-    replacements = {}
-    for func in self.funcs:
-      rep = func
-      while rep in main.funcs:
-        rep += '_'
-        replacements[func] = rep
-    #print >> sys.stderr, 'replacements:', replacements
-
-    # sendings: add invokes for new tables
-    all_sendings = main.sendings
-    added_sending = False
-    for table in self.tables:
-      if table not in main.tables:
-        sig = table[table.rfind('_')+1:]
-        all_sendings['invoke_%s' % sig] = shared.JS.make_invoke(sig, named=False)
-        added_sending = True
-
-    # imports
-    all_imports = main.imports
-    for key, value in self.imports.iteritems():
-      if key in self.funcs or key in main.funcs: continue # external function in one module, implemented in the other
-      value_concrete = '.' not in value # env.key means it is an import, an external value, and not a concrete one
-      main_value = main.imports.get(key)
-      main_value_concrete = main_value and '.' not in main_value
-      if value_concrete and main_value_concrete: continue # standard global var
-      if not main_value or value_concrete:
-        if '+' in value:
-          # relocate
-          value = value.replace('(', '').replace(')', '').replace('| 0', '').replace('|0', '').replace(' ', '')
-          left, right = value.split('+')
-          assert left == 'H_BASE'
-          value = str(main.staticbump + int(right))
-        all_imports[key] = value
-      if (value_concrete or main_value_concrete) and key in all_sendings:
-        del all_sendings[key] # import of external value no longer needed
-    main.imports_js = '\n'.join(['var %s = %s;' % (key, value) for key, value in all_imports.iteritems()]) + '\n'
-
-    # check for undefined references to global variables
-    def check_import(key, value):
-      if value.startswith('+') or value.endswith('|0'): # ignore functions
-        if key not in all_sendings:
-          print >> sys.stderr, 'warning: external variable %s is still not defined after linking' % key
-          all_sendings[key] = '0'
-    for key, value in all_imports.iteritems(): check_import(key, value)
-
-    if added_sending:
-      sendings_js = ', '.join(['%s: %s' % (key, value) for key, value in all_sendings.iteritems()])
-      sendings_start = main.post_js.find('}, { ')+5
-      sendings_end = main.post_js.find(' }, buffer);')
-      main.post_js = main.post_js[:sendings_start] + sendings_js + main.post_js[sendings_end:]
-
-    # tables
-    f_bases = {}
-    f_sizes = {}
-    for table, data in self.tables.iteritems():
-      main.tables[table] = self.merge_tables(table, main.tables.get(table), data, replacements, f_bases, f_sizes)
-    main.combine_tables()
-    #print >> sys.stderr, 'f bases', f_bases
-
-    # relocate
-    temp = shared.Building.js_optimizer(self.filename, ['asm', 'relocate', 'last'], extra_info={
-      'replacements': replacements,
-      'fBases': f_bases,
-      'hBase': main.staticbump
-    })
-    #print >> sys.stderr, 'relocated side into', temp
-    relocated_funcs = AsmModule(temp)
-    shared.try_delete(temp)
-    main.extra_funcs_js = relocated_funcs.funcs_js.replace(js_optimizer.start_funcs_marker, '\n')
-
-    # update function table uses
-    ft_marker = 'FUNCTION_TABLE_'
-
-    def update_fts(what):
-      updates = []
-      i = 1 # avoid seeing marker in recursion
-      while 1:
-        i = what.find(ft_marker, i)
-        if i < 0: break;
-        start = i
-        end = what.find('[', start)
-        table = what[i:end]
-        if table not in f_sizes:
-          # table was not modified
-          i += len(ft_marker)
-          continue
-        nesting = 1
-        while nesting > 0:
-          next = what.find(']', end+1)
-          nesting -= 1
-          nesting += what.count('[', end+1, next)
-          end = next
-        assert end > 0
-        mask = what.rfind('&', start, end)
-        assert mask > 0 and end - mask <= 13
-        fixed = update_fts(what[start:mask+1] + str(f_sizes[table]-1) + ']')
-        updates.append((start, end, fixed))
-        i = end # additional function table uses were done by recursion
-      # apply updates
-      if len(updates) == 0: return what
-      parts = []
-      so_far = 0
-      for i in range(len(updates)):
-        start, end, fixed = updates[i]
-        parts.append(what[so_far:start])
-        parts.append(fixed)
-        so_far = end+1
-      parts.append(what[so_far:])
-      return ''.join(parts)
-
-    main.funcs_js = update_fts(main.funcs_js)
-    main.extra_funcs_js = update_fts(main.extra_funcs_js)
-
-    # global initializers
-    if self.global_inits:
-      my_global_inits = map(lambda init: replacements[init] if init in replacements else init, self.global_inits)
-      all_global_inits = map(lambda init: '{ func: function() { %s() } }' % init, main.global_inits + my_global_inits)
-      all_global_inits_js = '/* global initializers */ __ATINIT__.push(' + ','.join(all_global_inits) + ');'
-      if main.global_inits:
-        target = main.global_inits_js
-      else:
-        target = '// === Body ===\n'
-        all_global_inits_js = target + all_global_inits_js
-      main.pre_js = main.pre_js.replace(target, all_global_inits_js)
-
-    # exports
-    def rep_exp(export):
-      key, value = export.split(':')
-      if key in replacements:
-        repped = replacements[key]
-        return repped + ': ' + repped
-      return export
-    my_exports = map(rep_exp, self.exports)
-    exports = main.exports.union(my_exports)
-    main.exports_js = 'return {' + ','.join(list(exports)) + '};\n})\n'
-
-    # post
-    def rep_def(deff):
-      key = deff.split(' ')[1]
-      if key in replacements:
-        rep = replacements[key]
-        return 'var %s = Module["%s"] = asm["%s"];\n' % (rep, rep, rep)
-      return deff
-    my_module_defs = map(rep_def, self.module_defs)
-    new_module_defs = set(my_module_defs).difference(main.module_defs)
-    if len(new_module_defs) > 0:
-      position = main.post_js.find('Runtime.') # Runtime is the start of the hardcoded ones
-      main.post_js = main.post_js[:position] + ''.join(list(new_module_defs)) + '\n' + main.post_js[position:]
-
-  def write(self, out):
-    f = open(out, 'w')
-    f.write(self.pre_js)
-    f.write(self.pre_imports_js)
-    f.write(self.imports_js)
-    f.write(self.funcs_js)
-    f.write(self.extra_funcs_js)
-    f.write(self.tables_js)
-    f.write(self.exports_js)
-    f.write(self.post_js)
-    f.close()
-
-  # Utilities
-
-  def parse_tables(self, js):
-    tables = {}
-    parts = js.split(';')
-    for part in parts:
-      if '=' not in part: continue
-      part = part.split('var ')[1]
-      name, data = part.split(' = ')
-      tables[name] = data
-    return tables
-
-  def merge_tables(self, table, main, side, replacements, f_bases, f_sizes):
-    sig = table.split('_')[-1]
-    side = side[1:-1].split(',')
-    side = map(lambda f: replacements[f] if f in replacements else f, side)
-    if not main:
-      f_bases[sig] = 0
-      f_sizes[table] = len(side)
-      return '[' + ','.join(side) + ']'
-    main = main[1:-1].split(',')
-    # TODO: handle non-aliasing case too
-    assert len(main) % 2 == 0
-    f_bases[sig] = len(main)
-    ret = main + side
-    size = 2
-    while size < len(ret): size *= 2
-    aborter = ret[1] # we can assume odd indexes have an aborting function with the right signature
-    ret = ret + [aborter]*(size - len(ret))
-    assert len(ret) == size
-    f_sizes[table] = size
-    return '[' + ','.join(ret) + ']'
-
-  def combine_tables(self):
-    self.tables_js = '// EMSCRIPTEN_END_FUNCS\n'
-    for table, data in self.tables.iteritems():
-      self.tables_js += 'var %s = %s;\n' % (table, data)
-
 main = AsmModule(main)
 side = AsmModule(side)
 
diff --git a/src/analyzer.js b/src/analyzer.js
index b1f0b585..1a752305 100644
--- a/src/analyzer.js
+++ b/src/analyzer.js
@@ -338,7 +338,7 @@ function analyzer(data, sidePass) {
                 if (subItem != item && (!(subItem.intertype in UNUNFOLDABLE) ||
                                        (subItem.intertype == 'value' && isNumber(subItem.ident) && isIllegalType(subItem.type)))) {
                   if (item.intertype == 'phi') {
-                    assert(subItem.intertype == 'value' || subItem.intertype == 'structvalue', 'We can only unfold illegal constants in phis');
+                    assert(subItem.intertype == 'value' || subItem.intertype == 'structvalue' || subItem.intertype in PARSABLE_LLVM_FUNCTIONS, 'We can only unfold some expressions in phis');
                     // we must handle this in the phi itself, if we unfold normally it will not be pushed back with the phi
                   } else {
                     var tempIdent = '$$etemp$' + (tempId++);
diff --git a/src/library.js b/src/library.js
index f7c7a3ba..85d1d13f 100644
--- a/src/library.js
+++ b/src/library.js
@@ -29,7 +29,8 @@ LibraryManager.library = {
   _impure_ptr: 'allocate(1, "i32*", ALLOC_STATIC)',
 
   $FS__deps: ['$ERRNO_CODES', '__setErrNo', 'stdin', 'stdout', 'stderr', '_impure_ptr'],
-  $FS__postset: '__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });' +
+  $FS__postset: 'FS.staticInit();' +
+                '__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });' +
                 '__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });' +
                 '__ATEXIT__.push({ func: function() { FS.quit() } });' +
                 // export some names through closure
@@ -223,7 +224,6 @@ LibraryManager.library = {
     // set to true and the object is a symbolic link, it will be returned as is
     // instead of being resolved. Links embedded in the path are still resolved.
     findObject: function(path, dontResolveLastLink) {
-      FS.ensureRoot();
       var ret = FS.analyzePath(path, dontResolveLastLink);
       if (ret.exists) {
         return ret.object;
@@ -509,8 +509,7 @@ LibraryManager.library = {
       if (!success) ___setErrNo(ERRNO_CODES.EIO);
       return success;
     },
-    ensureRoot: function() {
-      if (FS.root) return;
+    staticInit: function () {
       // The main file system tree. All the contents are inside this.
       FS.root = {
         read: true,
@@ -521,6 +520,11 @@ LibraryManager.library = {
         inodeNumber: 1,
         contents: {}
       };
+      // Create the temporary folder, if not already created
+      try {
+        FS.createFolder('/', 'tmp', true, true);
+      } catch(e) {}
+      FS.createFolder('/', 'dev', true, true);
     },
     // Initializes the filesystems with stdin/stdout/stderr devices, given
     // optional handlers.
@@ -529,8 +533,6 @@ LibraryManager.library = {
       assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
       FS.init.initialized = true;
 
-      FS.ensureRoot();
-
       // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
       input = input || Module['stdin'];
       output = output || Module['stdout'];
@@ -583,21 +585,15 @@ LibraryManager.library = {
       if (!error.printer) error.printer = Module['printErr'];
       if (!error.buffer) error.buffer = [];
 
-      // Create the temporary folder, if not already created
-      try {
-        FS.createFolder('/', 'tmp', true, true);
-      } catch(e) {}
-
       // Create the I/O devices.
-      var devFolder = FS.createFolder('/', 'dev', true, true);
-      var stdin = FS.createDevice(devFolder, 'stdin', input);
+      var stdin = FS.createDevice('/dev', 'stdin', input);
       stdin.isTerminal = !stdinOverridden;
-      var stdout = FS.createDevice(devFolder, 'stdout', null, output);
+      var stdout = FS.createDevice('/dev', 'stdout', null, output);
       stdout.isTerminal = !stdoutOverridden;
-      var stderr = FS.createDevice(devFolder, 'stderr', null, error);
+      var stderr = FS.createDevice('/dev', 'stderr', null, error);
       stderr.isTerminal = !stderrOverridden;
-      FS.createDevice(devFolder, 'tty', input, output);
-      FS.createDevice(devFolder, 'null', function(){}, function(){});
+      FS.createDevice('/dev', 'tty', input, output);
+      FS.createDevice('/dev', 'null', function(){}, function(){});
 
       // Create default streams.
       FS.streams[1] = {
@@ -1165,7 +1161,7 @@ LibraryManager.library = {
     ['i32', 'f_namemax']]),
   statvfs__deps: ['$FS', '__statvfs_struct_layout'],
   statvfs: function(path, buf) {
-    // http://pubs.opengroup.org/onlinepubs/7908799/xsh/stat.html
+    // http://pubs.opengroup.org/onlinepubs/009695399/functions/statvfs.html
     // int statvfs(const char *restrict path, struct statvfs *restrict buf);
     var offsets = ___statvfs_struct_layout;
     // NOTE: None of the constants here are true. We're just returning safe and
@@ -1417,6 +1413,16 @@ LibraryManager.library = {
   },
 
   // ==========================================================================
+  // sys/file.h
+  // ==========================================================================
+
+  flock: function(fd, operation) {
+    // int flock(int fd, int operation);
+    // Pretend to succeed
+    return 0;
+  },
+
+  // ==========================================================================
   // poll.h
   // ==========================================================================
 
@@ -2133,20 +2139,7 @@ LibraryManager.library = {
   _exit: function(status) {
     // void _exit(int status);
     // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
-
-    function ExitStatus() {
-      this.name = "ExitStatus";
-      this.message = "Program terminated with exit(" + status + ")";
-      this.status = status;
-      Module.print('Exit Status: ' + status);
-    };
-    ExitStatus.prototype = new Error();
-    ExitStatus.prototype.constructor = ExitStatus;
-
-    exitRuntime();
-    ABORT = true;
-
-    throw new ExitStatus();
+    Module['exit'](status);
   },
   fork__deps: ['__setErrNo', '$ERRNO_CODES'],
   fork: function() {
@@ -3653,29 +3646,19 @@ LibraryManager.library = {
     ___setErrNo(ERRNO_CODES.EAGAIN);
     return -1;
   },
-  fscanf__deps: ['$FS', '__setErrNo', '$ERRNO_CODES',
-                 '_scanString', 'fgetc', 'fseek', 'ftell'],
+  fscanf__deps: ['$FS', '_scanString', 'fgetc', 'ungetc'],
   fscanf: function(stream, format, varargs) {
     // int fscanf(FILE *restrict stream, const char *restrict format, ... );
     // http://pubs.opengroup.org/onlinepubs/000095399/functions/scanf.html
     if (FS.streams[stream]) {
-      var i = _ftell(stream), SEEK_SET = 0;
-      // if the stream does not support seeking backwards (e.g. stdin), buffer it here
-      var buffer = [], bufferIndex = 0;
+      var buffer = [];
       var get = function() {
-        if (bufferIndex < buffer.length) {
-          return buffer[bufferIndex++];
-        }
-        i++;
-        bufferIndex++;
         var c = _fgetc(stream);
         buffer.push(c);
         return c;
       };
       var unget = function() {
-        if (_fseek(stream, --i, SEEK_SET) !== 0) {
-          bufferIndex--;
-        }
+        _ungetc(buffer.pop(), stream);
       };
       return __scanString(format, get, unget, varargs);
     } else {
@@ -3876,6 +3859,20 @@ LibraryManager.library = {
 
   // TODO: Implement mremap.
 
+  mprotect: function(addr, len, prot) {
+    // int mprotect(void *addr, size_t len, int prot);
+    // http://pubs.opengroup.org/onlinepubs/7908799/xsh/mprotect.html
+    // Pretend to succeed
+    return 0;
+  },
+
+  msync: function(addr, len, flags) {
+    // int msync(void *addr, size_t len, int flags);
+    // http://pubs.opengroup.org/onlinepubs/009696799/functions/msync.html
+    // Pretend to succeed
+    return 0;
+  },
+
   // ==========================================================================
   // stdlib.h
   // ==========================================================================
@@ -3939,13 +3936,16 @@ LibraryManager.library = {
   __cxa_atexit: 'atexit',
 
   abort: function() {
-    ABORT = true;
-    throw 'abort() at ' + (new Error().stack);
+    Module['abort']();
   },
 
   bsearch: function(key, base, num, size, compar) {
     var cmp = function(x, y) {
-      return Runtime.dynCall('iii', compar, [x, y])
+#if ASM_JS
+      return Module['dynCall_iii'](compar, x, y);
+#else
+      return FUNCTION_TABLE[compar](x, y);
+#endif
     };
     var left = 0;
     var right = num;
@@ -3955,7 +3955,6 @@ LibraryManager.library = {
       mid = (left + right) >>> 1;
       addr = base + (mid * size);
       test = cmp(key, addr);
-
       if (test < 0) {
         right = mid;
       } else if (test > 0) {
@@ -4175,13 +4174,14 @@ LibraryManager.library = {
     if (num == 0 || size == 0) return;
     // forward calls to the JavaScript sort method
     // first, sort the items logically
-    var comparator = function(x, y) {
-      return Runtime.dynCall('iii', cmp, [x, y]);
-    }
     var keys = [];
     for (var i = 0; i < num; i++) keys.push(i);
     keys.sort(function(a, b) {
-      return comparator(base+a*size, base+b*size);
+#if ASM_JS
+      return Module['dynCall_iii'](cmp, base+a*size, base+b*size);
+#else
+      return FUNCTION_TABLE[cmp](base+a*size, base+b*size);
+#endif
     });
     // apply the sort
     var temp = _malloc(num*size);
@@ -4459,6 +4459,13 @@ LibraryManager.library = {
   llvm_memmove_p0i8_p0i8_i32: 'memmove',
   llvm_memmove_p0i8_p0i8_i64: 'memmove',
 
+  bcopy__deps: ['memmove'],
+  bcopy: function(src, dest, num) {
+    // void bcopy(const void *s1, void *s2, size_t n);
+    // http://pubs.opengroup.org/onlinepubs/009695399/functions/bcopy.html
+    _memmove(dest, src, num);
+  },
+
   memset__inline: function(ptr, value, num, align) {
     return makeSetValues(ptr, 0, value, 'null', num, align);
   },
@@ -4947,7 +4954,17 @@ LibraryManager.library = {
            (chr >= {{{ charCode('{') }}} && chr <= {{{ charCode('~') }}});
   },
   isspace: function(chr) {
-    return chr in { 32: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0 };
+    switch(chr) {
+      case 32:
+      case 9:
+      case 10:
+      case 11:
+      case 12:
+      case 13:
+        return true;
+      default:
+        return false;
+    };
   },
   isblank: function(chr) {
     return chr == {{{ charCode(' ') }}} || chr == {{{ charCode('\t') }}};
@@ -6161,9 +6178,14 @@ LibraryManager.library = {
     {{{ makeSetValue('tmPtr', 'offsets.tm_wday', 'date.getUTCDay()', 'i32') }}}
     {{{ makeSetValue('tmPtr', 'offsets.tm_gmtoff', '0', 'i32') }}}
     {{{ makeSetValue('tmPtr', 'offsets.tm_isdst', '0', 'i32') }}}
-
-    var start = new Date(date.getFullYear(), 0, 1);
-    var yday = Math.round((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
+    var start = new Date(date); // define date using UTC, start from Jan 01 00:00:00 UTC
+    start.setUTCDate(1);
+    start.setUTCMonth(0);
+    start.setUTCHours(0);
+    start.setUTCMinutes(0);
+    start.setUTCSeconds(0);
+    start.setUTCMilliseconds(0);
+    var yday = Math.floor((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
     {{{ makeSetValue('tmPtr', 'offsets.tm_yday', 'yday', 'i32') }}}
 
     var timezone = "GMT";
@@ -6174,7 +6196,6 @@ LibraryManager.library = {
 
     return tmPtr;
   },
-
   timegm__deps: ['mktime'],
   timegm: function(tmPtr) {
     _tzset();
@@ -7823,7 +7844,7 @@ LibraryManager.library = {
   inet_pton__deps: ['__setErrNo', '$ERRNO_CODES', 'inet_addr'],
   inet_pton: function(af, src, dst) {
     // int af, const char *src, void *dst
-    if ((af ^ {{{ cDefine("AF_INET") }}}) !==  0) { ___setErrNo(ERRNO_CODES.EAFNOSUPPORT); return -1; }
+    if ((af ^ {{{ cDefine('AF_INET') }}}) !==  0) { ___setErrNo(ERRNO_CODES.EAFNOSUPPORT); return -1; }
     var ret = _inet_addr(src);
     if (ret == -1 || isNaN(ret)) return 0;
     setValue(dst, ret, 'i32');
@@ -7911,7 +7932,7 @@ LibraryManager.library = {
     var aliasesBuf = _malloc(4);
     setValue(aliasesBuf, 0, 'i8*');
     setValue(ret+___hostent_struct_layout.h_aliases, aliasesBuf, 'i8**');
-    setValue(ret+___hostent_struct_layout.h_addrtype, {{{ cDefine("AF_INET") }}}, 'i32');
+    setValue(ret+___hostent_struct_layout.h_addrtype, {{{ cDefine('AF_INET') }}}, 'i32');
     setValue(ret+___hostent_struct_layout.h_length, 4, 'i32');
     var addrListBuf = _malloc(12);
     setValue(addrListBuf, addrListBuf+8, 'i32*');
diff --git a/src/library_gl.js b/src/library_gl.js
index d0f1a692..54b2f956 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -1318,7 +1318,7 @@ var LibraryGL = {
       GLEmulation.fogColor = new Float32Array(4);
 
       // Add some emulation workarounds
-      Module.printErr('WARNING: using emscripten GL emulation. This is a collection of limited workarounds, do not expect it to work');
+      Module.printErr('WARNING: using emscripten GL emulation. This is a collection of limited workarounds, do not expect it to work. (If you do not want this, build with -s DISABLE_GL_EMULATION=1)');
 #if GL_UNSAFE_OPTS == 0
       Module.printErr('WARNING: using emscripten GL emulation unsafe opts. If weirdness happens, try -s GL_UNSAFE_OPTS=0');
 #endif
diff --git a/src/library_jansson.js b/src/library_jansson.js
index 93f239fc..da8c5aa8 100644
--- a/src/library_jansson.js
+++ b/src/library_jansson.js
@@ -79,7 +79,7 @@ var LibraryJansson = {
       load: function(string, flags, error) {
         // This is potentially a security problem.
         // TODO: Make sure everything is properly escaped
-        var json_obj = eval('(' + string + ')');
+        var json_obj = JSON.parse(string);
 
         if (json_obj != null) {
           // The context is an array storing all child nodes.
diff --git a/src/library_openal.js b/src/library_openal.js
index 6a97fce7..d2516559 100644
--- a/src/library_openal.js
+++ b/src/library_openal.js
@@ -5,6 +5,8 @@ var LibraryOpenAL = {
   $AL: {
     contexts: [],
     currentContext: null,
+    QUEUE_INTERVAL: 25,
+    QUEUE_LOOKAHEAD: 100
   },
 
   alcProcessContext: function(context) {},
@@ -39,6 +41,7 @@ var LibraryOpenAL = {
 
   alcDestroyContext: function(context) {
     // Stop playback, etc
+    clearInterval(context.interval);
   },
 
   alcCloseDevice: function(device) {
@@ -54,6 +57,7 @@ var LibraryOpenAL = {
     }
   },
 
+  alcCreateContext__deps: ['updateSources'],
   alcCreateContext: function(device, attrList) {
     if (device != 1) {
       return 0;
@@ -76,18 +80,152 @@ var LibraryOpenAL = {
     }
 
     if (ctx) {
-      AL.contexts.push({ctx: ctx, err: 0, src: [], buf: []});
+      var context = {
+        ctx: ctx,
+        err: 0,
+        src: [],
+        buf: [],
+        interval: setInterval(function () { _updateSources(context); }, AL.QUEUE_INTERVAL)
+      };
+      AL.contexts.push(context);
       return AL.contexts.length;
     } else {
       return 0;
     }
   },
 
+  updateSources__deps: ['updateSource'],
+  updateSources: function (context) {
+    for (var i = 0; i < context.src.length; i++) {
+      _updateSource(context.src[i]);
+    }
+  },
+
+  updateSource__deps: ['setSourceState'],
+  updateSource: function (src) {
+#if OPENAL_DEBUG
+    var idx = AL.currentContext.src.indexOf(src);
+#endif
+    if (src.state !== 0x1012 /* AL_PLAYING */) {
+      return;
+    }
+
+    var currentTime = AL.currentContext.ctx.currentTime;
+    var startTime = src.bufferPosition;
+
+    for (var i = src.buffersPlayed; i < src.queue.length; i++) {
+      var entry = src.queue[i];
+
+      var startOffset = startTime - currentTime;
+      var endTime = startTime + entry.buffer.duration;
+
+      // Clean up old buffers.
+      if (currentTime >= endTime) {
+        // Update our location in the queue.
+        src.bufferPosition = endTime;
+        src.buffersPlayed = i + 1;
+
+        // Stop / restart the source when we hit the end.
+        if (src.buffersPlayed >= src.queue.length) {
+          if (src.loop) {
+            _setSourceState(src, 0x1012 /* AL_PLAYING */);
+          } else {
+            _setSourceState(src, 0x1014 /* AL_STOPPED */);
+          }
+        }
+      }
+      // Process all buffers that'll be played before the next tick.
+      else if (startOffset < (AL.QUEUE_LOOKAHEAD / 1000) && !entry.src) {
+        // If the start offset is negative, we need to offset the actual buffer.
+        var offset = Math.abs(Math.min(startOffset, 0));
+
+        entry.src = AL.currentContext.ctx.createBufferSource();
+        entry.src.buffer = entry.buffer;
+        entry.src.connect(src.gain);
+        entry.src.start(startTime, offset);
+        
+#if OPENAL_DEBUG
+        console.log('updateSource queuing buffer ' + i + ' for source ' + idx + ' at ' + startTime + ' (offset by ' + offset + ')');
+#endif
+      }
+
+      startTime = endTime;
+    }
+  },
+
+  setSourceState__deps: ['updateSource', 'stopSourceQueue'],
+  setSourceState: function (src, state) {
+#if OPENAL_DEBUG
+    var idx = AL.currentContext.src.indexOf(src);
+#endif
+    if (state === 0x1012 /* AL_PLAYING */) {
+      if (src.state !== 0x1013 /* AL_PAUSED */) {
+        src.state = 0x1012 /* AL_PLAYING */;
+        // Reset our position.
+        src.bufferPosition = AL.currentContext.ctx.currentTime;
+        src.buffersPlayed = 0;
+#if OPENAL_DEBUG
+        console.log('setSourceState resetting and playing source ' + idx);
+#endif
+      } else {
+        src.state = 0x1012 /* AL_PLAYING */;
+        // Use the current offset from src.bufferPosition to resume at the correct point.
+        src.bufferPosition = AL.currentContext.ctx.currentTime - src.bufferPosition;
+#if OPENAL_DEBUG
+        console.log('setSourceState resuming source ' + idx + ' at ' + src.bufferPosition.toFixed(4));
+#endif
+      }
+      _stopSourceQueue(src);
+      _updateSource(src);
+    } else if (state === 0x1013 /* AL_PAUSED */) {
+      if (src.state === 0x1012 /* AL_PLAYING */) {
+        src.state = 0x1013 /* AL_PAUSED */;
+        // Store off the current offset to restore with on resume.
+        src.bufferPosition = AL.currentContext.ctx.currentTime - src.bufferPosition;
+        _stopSourceQueue(src);
+#if OPENAL_DEBUG
+        console.log('setSourceState pausing source ' + idx + ' at ' + src.bufferPosition.toFixed(4));
+#endif
+      }
+    } else if (state === 0x1014 /* AL_STOPPED */) {
+      if (src.state !== 0x1011 /* AL_INITIAL */) {
+        src.state = 0x1014 /* AL_STOPPED */;
+        src.buffersPlayed = src.queue.length;
+        _stopSourceQueue(src);
+#if OPENAL_DEBUG
+        console.log('setSourceState stopping source ' + idx);
+#endif
+      }
+    } else if (state == 0x1011 /* AL_INITIAL */) {
+      if (src.state !== 0x1011 /* AL_INITIAL */) {
+        src.state = 0x1011 /* AL_INITIAL */;
+        src.bufferPosition = 0;
+        src.buffersPlayed = 0;
+#if OPENAL_DEBUG
+        console.log('setSourceState initializing source ' + idx);
+#endif
+      }
+    }
+  },
+
+  stopSourceQueue: function (src) {
+    for (var i = 0; i < src.queue.length; i++) {
+      var entry = src.queue[i];
+      if (entry.src) {
+        entry.src.stop(0);
+        entry.src = null;
+      }
+    }
+  },
+
   alGetError: function() {
     if (!AL.currentContext) {
       return 0xA004 /* AL_INVALID_OPERATION */;
     } else {
-      return AL.currentContext.err;
+      // Reset error on get.
+      var err = AL.currentContext.err;
+      AL.currentContext.err = 0 /* AL_NO_ERROR */;
+      return err;
     }
   },
 
@@ -97,12 +235,12 @@ var LibraryOpenAL = {
     return _alGetError();
   },
 
-  alDeleteSources: function(count, sources)
-  {
+  alDeleteSources: function(count, sources) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
       console.error("alDeleteSources called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     for (var i = 0; i < count; ++i) {
@@ -116,57 +254,126 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alGenSources called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     for (var i = 0; i < count; ++i) {
       var gain = AL.currentContext.ctx.createGain();
-      var panner = AL.currentContext.ctx.createPanner();
-      panner.panningModel = "equalpower";
-      panner.distanceModel = "linear";
-      panner.rolloffFactor = 0.3;
-      gain.connect(panner);
-      panner.connect(AL.currentContext.ctx.destination);
+      gain.connect(AL.currentContext.ctx.destination);
       AL.currentContext.src.push({
+        state: 0x1011 /* AL_INITIAL */,
+        queue: [],
         loop: false,
-        buffer: null,
+        get refDistance() {
+          return this._refDistance || 1;
+        },
+        set refDistance(val) {
+          this._refDistance = val;
+          if (this.panner) this.panner.refDistance = val;
+        },
+        get maxDistance() {
+          return this._maxDistance || 10000;
+        },
+        set maxDistance(val) {
+          this._maxDistance = val;
+          if (this.panner) this.panner.maxDistance = val;
+        },
+        get rolloffFactor() {
+          return this._rolloffFactor || 1;
+        },
+        set rolloffFactor(val) {
+          this._rolloffFactor = val;
+          if (this.panner) this.panner.rolloffFactor = val;
+        },
+        get position() {
+          return this._position || [0, 0, 0];
+        },
+        set position(val) {
+          this._position = val;
+          if (this.panner) this.panner.setPosition(val[0], val[1], val[2]);
+        },
+        get velocity() {
+          return this._velocity || [0, 0, 0];
+        },
+        set velocity(val) {
+          this._velocity = val;
+          if (this.panner) this.panner.setVelocity(val[0], val[1], val[2]);
+        },
         gain: gain,
-        panner: panner,
-        paused: false,
-        playTime: -1,
-        pausedTime: 0
+        panner: null,
+        buffersPlayed: 0,
+        bufferPosition: 0
       });
       {{{ makeSetValue('sources', 'i*4', 'AL.currentContext.src.length', 'i32') }}};
     }
   },
 
+  alSourcei__deps: ['updateSource'],
   alSourcei: function(source, param, value) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
       console.error("alSourcei called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
       console.error("alSourcei called with an invalid source");
 #endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
     switch (param) {
     case 0x1007 /* AL_LOOPING */:
-      AL.currentContext.src[source - 1].loop = (value != 0 /* AL_FALSE */);
+      src.loop = (value === 1 /* AL_TRUE */);
       break;
     case 0x1009 /* AL_BUFFER */:
+      var buffer = AL.currentContext.buf[value - 1];
       if (value == 0) {
-        AL.currentContext.src[source - 1].buffer = null;
+        src.queue = [];
+      } else {
+        src.queue = [{ buffer: buffer }];
+      }
+      _updateSource(src);
+      break;
+    case 0x202 /* AL_SOURCE_RELATIVE */:
+      if (value === 1 /* AL_TRUE */) {
+        if (src.panner) {
+          src.panner = null;
+            
+          // Disconnect from the panner.
+          src.gain.disconnect();
+
+          src.gain.connect(AL.currentContext.ctx.destination);
+        }
+      } else if (value === 0 /* AL_FALSE */) {
+        if (!src.panner) {
+          var panner = src.panner = AL.currentContext.ctx.createPanner();
+          panner.panningModel = "equalpower";
+          panner.distanceModel = "linear";
+          panner.refDistance = src.refDistance;
+          panner.maxDistance = src.maxDistance;
+          panner.rolloffFactor = src.rolloffFactor;
+          panner.setPosition(src.position[0], src.position[1], src.position[2]);
+          panner.setVelocity(src.velocity[0], src.velocity[1], src.velocity[2]);
+          panner.connect(AL.currentContext.ctx.destination);
+
+          // Disconnect from the default source.
+          src.gain.disconnect();
+
+          src.gain.connect(panner);
+        }
       } else {
-        AL.currentContext.src[source - 1].buffer = AL.currentContext.buf[value - 1].buf;
+        AL.currentContext.err = 0xA003 /* AL_INVALID_VALUE */;
       }
       break;
     default:
 #if OPENAL_DEBUG
       console.log("alSourcei with param " + param + " not implemented yet");
 #endif
+      AL.currentContext.err = 0xA002 /* AL_INVALID_ENUM */;
       break;
     }
   },
@@ -176,130 +383,168 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSourcef called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
       console.error("alSourcef called with an invalid source");
 #endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
     switch (param) {
-    case 0x100A /* AL_GAIN */:
-      if (AL.currentContext.src[source - 1]) {
-        AL.currentContext.src[source - 1].gain.gain.value = value;
-      }
-      break;
     case 0x1003 /* AL_PITCH */:
 #if OPENAL_DEBUG
-      console.log("alSourcef was called with AL_PITCH, but Web Audio does not support static pitch changes");
+      console.log("alSourcef was called with 0x1003 /* AL_PITCH */, but Web Audio does not support static pitch changes");
 #endif
       break;
+    case 0x100A /* AL_GAIN */:
+      src.gain.gain.value = value;
+      break;
+    // case 0x100D /* AL_MIN_GAIN */:
+    //   break;
+    // case 0x100E /* AL_MAX_GAIN */:
+    //   break;
+    case 0x1023 /* AL_MAX_DISTANCE */:
+      src.maxDistance = value;
+      break;
+    case 0x1021 /* AL_ROLLOFF_FACTOR */:
+      src.rolloffFactor = value;
+      break;
+    // case 0x1022 /* AL_CONE_OUTER_GAIN */:
+    //   break;
+    // case 0x1001 /* AL_CONE_INNER_ANGLE */:
+    //   break;
+    // case 0x1002 /* AL_CONE_OUTER_ANGLE */:
+    //   break;
+    case 0x1020 /* AL_REFERENCE_DISTANCE */:
+      src.refDistance = value;
+      break;
     default:
 #if OPENAL_DEBUG
       console.log("alSourcef with param " + param + " not implemented yet");
 #endif
+      AL.currentContext.err = 0xA002 /* AL_INVALID_ENUM */;
       break;
     }
   },
 
-  alSourcefv: function(source, param, value) {
+  alSource3f: function(source, param, v1, v2, v3) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
-      console.error("alSourcefv called without a valid context");
+      console.error("alSource3f called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
-      console.error("alSourcefv called with an invalid source");
+      console.error("alSource3f called with an invalid source");
 #endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
     switch (param) {
     case 0x1004 /* AL_POSITION */:
-      AL.currentContext.src[source - 1].panner.setPosition(
-          {{{ makeGetValue('value', '0', 'float') }}},
-          {{{ makeGetValue('value', '4', 'float') }}},
-          {{{ makeGetValue('value', '8', 'float') }}}
-        );
+      src.position = [v1, v2, v3];
       break;
     case 0x1006 /* AL_VELOCITY */:
-      AL.currentContext.src[source - 1].panner.setVelocity(
-          {{{ makeGetValue('value', '0', 'float') }}},
-          {{{ makeGetValue('value', '4', 'float') }}},
-          {{{ makeGetValue('value', '8', 'float') }}}
-        );
+      src.velocity = [v1, v2, v3];
       break;
     default:
 #if OPENAL_DEBUG
-      console.log("alSourcefv with param " + param + " not implemented yet");
+      console.log("alSource3f with param " + param + " not implemented yet");
 #endif
+      AL.currentContext.err = 0xA002 /* AL_INVALID_ENUM */;
       break;
     }
   },
 
+  alSourcefv__deps: ['alSource3f'],
+  alSourcefv: function(source, param, value) {
+    _alSource3f(source, param,
+      {{{ makeGetValue('value', '0', 'float') }}},
+      {{{ makeGetValue('value', '4', 'float') }}},
+      {{{ makeGetValue('value', '8', 'float') }}});
+  },
+
+  alSourceQueueBuffers__deps: ["updateSource"],
   alSourceQueueBuffers: function(source, count, buffers) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
       console.error("alSourceQueueBuffers called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
       console.error("alSourceQueueBuffers called with an invalid source");
 #endif
-      return;
-    }
-    if (count != 1) {
-#if OPENAL_DEBUG
-      console.error("Queuing multiple buffers using alSourceQueueBuffers is not supported yet");
-#endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
     for (var i = 0; i < count; ++i) {
-      var buffer = {{{ makeGetValue('buffers', 'i*4', 'i32') }}};
-      if (buffer > AL.currentContext.buf.length) {
+      var bufferIdx = {{{ makeGetValue('buffers', 'i*4', 'i32') }}};
+      if (bufferIdx > AL.currentContext.buf.length) {
 #if OPENAL_DEBUG
         console.error("alSourceQueueBuffers called with an invalid buffer");
 #endif
+        AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
         return;
       }
-      AL.currentContext.src[source - 1].buffer = AL.currentContext.buf[buffer - 1].buf;
     }
+
+    for (var i = 0; i < count; ++i) {
+      var bufferIdx = {{{ makeGetValue('buffers', 'i*4', 'i32') }}};
+      var buffer = AL.currentContext.buf[bufferIdx - 1];
+      src.queue.push({ buffer: buffer, src: null });
+    }
+
+    _updateSource(src);
   },
 
-  alSourceUnqueueBuffers: function(source, count, buffers)
-  {
+  alSourceUnqueueBuffers__deps: ["updateSource"],
+  alSourceUnqueueBuffers: function(source, count, buffers) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
       console.error("alSourceUnqueueBuffers called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
       console.error("alSourceUnqueueBuffers called with an invalid source");
 #endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
-    if (count != 1) {
-#if OPENAL_DEBUG
-      console.error("Queuing multiple buffers using alSourceUnqueueBuffers is not supported yet");
-#endif
+
+    if (count > src.buffersPlayed) {
+      AL.currentContext.err = 0xA003 /* AL_INVALID_VALUE */;
       return;
     }
-    for (var i = 0; i < count; ++i) {
-      var buffer = AL.currentContext.src[source - 1].buffer;
-      for (var j = 0; j < AL.currentContext.buf.length; ++j) {
-        if (buffer == AL.currentContext.buf[j].buf) {
+
+    for (var i = 0; i < count; i++) {
+      var entry = src.queue.shift();
+      // Write the buffers index out to the return list.
+      for (var j = 0; j < AL.currentContext.buf.length; j++) {
+        var b = AL.currentContext.buf[j];
+        if (b && b == entry.buffer) {
           {{{ makeSetValue('buffers', 'i*4', 'j+1', 'i32') }}};
-          AL.currentContext.src[source - 1].buffer = null;
           break;
         }
       }
+      src.buffersPlayed--;
     }
+
+    _updateSource(src);
   },
 
   alDeleteBuffers: function(count, buffers)
@@ -308,21 +553,43 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alDeleteBuffers called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
+      return;
+    }
+    if (count > AL.currentContext.buf.length) {
+      AL.currentContext.err = 0xA003 /* AL_INVALID_VALUE */;
       return;
     }
+
     for (var i = 0; i < count; ++i) {
       var bufferIdx = {{{ makeGetValue('buffers', 'i*4', 'i32') }}} - 1;
-      if (bufferIdx < AL.currentContext.buf.length && AL.currentContext.buf[bufferIdx]) {
-        var buffer = AL.currentContext.buf[bufferIdx].buf;
-        for (var j = 0; j < AL.currentContext.src.length; ++j) {
-          if (buffer == AL.currentContext.src[j].buffer) {
-            AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION  */;
+
+      // Make sure the buffer index is valid.
+      if (bufferIdx >= AL.currentContext.buf.length || !AL.currentContext.buf[bufferIdx]) {
+        AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
+        return;
+      }
+
+      // Make sure the buffer is no longer in use.
+      var buffer = AL.currentContext.buf[bufferIdx];
+      for (var j = 0; j < AL.currentContext.src.length; ++j) {
+        var src = AL.currentContext.src[j];
+        if (!src) {
+          continue;
+        }
+        for (var k = 0; k < src.queue.length; k++) {
+          if (buffer === src.queue[k].buffer) {
+            AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
             return;
           }
         }
-        delete AL.currentContext.buf[bufferIdx];
       }
     }
+
+    for (var i = 0; i < count; ++i) {
+      var bufferIdx = {{{ makeGetValue('buffers', 'i*4', 'i32') }}} - 1;
+      delete AL.currentContext.buf[bufferIdx];
+    }
   },
 
   alGenBuffers: function(count, buffers) {
@@ -330,10 +597,11 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alGenBuffers called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     for (var i = 0; i < count; ++i) {
-      AL.currentContext.buf.push({buf: null});
+      AL.currentContext.buf.push(null);
       {{{ makeSetValue('buffers', 'i*4', 'AL.currentContext.buf.length', 'i32') }}};
     }
   },
@@ -343,6 +611,7 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alBufferData called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     if (buffer > AL.currentContext.buf.length) {
@@ -375,16 +644,21 @@ var LibraryOpenAL = {
 #endif
       return;
     }
-    AL.currentContext.buf[buffer - 1].buf = AL.currentContext.ctx.createBuffer(channels, size / (bytes * channels), freq);
+    try {
+      AL.currentContext.buf[buffer - 1] = AL.currentContext.ctx.createBuffer(channels, size / (bytes * channels), freq);
+    } catch (e) {
+      AL.currentContext.err = 0xA003 /* AL_INVALID_VALUE */;
+      return;
+    }
     var buf = new Array(channels);
     for (var i = 0; i < channels; ++i) {
-      buf[i] = AL.currentContext.buf[buffer - 1].buf.getChannelData(i);
+      buf[i] = AL.currentContext.buf[buffer - 1].getChannelData(i);
     }
     for (var i = 0; i < size / (bytes * channels); ++i) {
       for (var j = 0; j < channels; ++j) {
         switch (bytes) {
         case 1:
-          var val = {{{ makeGetValue('data', 'i*channels+j', 'i8') }}};
+          var val = {{{ makeGetValue('data', 'i*channels+j', 'i8') }}} & 0xff;  // unsigned
           buf[j][i] = -1.0 + val * (2/256);
           break;
         case 2:
@@ -396,110 +670,105 @@ var LibraryOpenAL = {
     }
   },
 
-  alSourcePlay__deps: ["alSourceStop"],
+  alSourcePlay__deps: ['setSourceState'],
   alSourcePlay: function(source) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
       console.error("alSourcePlay called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
       console.error("alSourcePlay called with an invalid source");
 #endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
-    var offset = 0;
-    if ("src" in AL.currentContext.src[source - 1] &&
-        AL.currentContext.src[source - 1]["src"].buffer ==
-        AL.currentContext.src[source - 1].buffer) {
-      if (AL.currentContext.src[source - 1].paused) {
-        // So now we have to resume playback, remember the offset here.
-        offset = AL.currentContext.src[source - 1].pausedTime -
-                 AL.currentContext.src[source - 1].playTime;
-      } else {
-        // If the source is already playing, we need to resume from beginning.
-        // We do that by stopping the current source and replaying it.
-        _alSourceStop(source);
-      }
-    }
-    var src = AL.currentContext.ctx.createBufferSource();
-    src.loop = AL.currentContext.src[source - 1].loop;
-    src.buffer = AL.currentContext.src[source - 1].buffer;
-    src.connect(AL.currentContext.src[source - 1].gain);
-    src.start(0, offset);
-    AL.currentContext.src[source - 1].playTime = AL.currentContext.ctx.currentTime;
-    AL.currentContext.src[source - 1].paused = false;
-    AL.currentContext.src[source - 1]['src'] = src;
+    _setSourceState(src, 0x1012 /* AL_PLAYING */);
   },
 
+  alSourceStop__deps: ['setSourceState'],
   alSourceStop: function(source) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
       console.error("alSourceStop called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
       console.error("alSourceStop called with an invalid source");
 #endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
-    if (AL.currentContext.src[source - 1] && "src" in AL.currentContext.src[source - 1]) {
-      AL.currentContext.src[source - 1]["src"].stop(0);
-      delete AL.currentContext.src[source - 1]["src"];
-    }
+    _setSourceState(src, 0x1014 /* AL_STOPPED */);
   },
 
+  alSourcePause__deps: ['setSourceState'],
   alSourcePause: function(source) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
       console.error("alSourcePause called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
       console.error("alSourcePause called with an invalid source");
 #endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
-    if ("src" in AL.currentContext.src[source - 1] &&
-        !AL.currentContext.src[source - 1].paused) {
-      AL.currentContext.src[source - 1].paused = true;
-      AL.currentContext.src[source - 1].pausedTime = AL.currentContext.ctx.currentTime;
-      AL.currentContext.src[source - 1]["src"].stop(0);
-      delete AL.currentContext.src[source - 1].src;
-    }
+    _setSourceState(src, 0x1013 /* AL_PAUSED */);
   },
 
+  alGetSourcei__deps: ['updateSource'],
   alGetSourcei: function(source, param, value) {
     if (!AL.currentContext) {
 #if OPENAL_DEBUG
       console.error("alGetSourcei called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
-    if (source > AL.currentContext.src.length) {
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
 #if OPENAL_DEBUG
       console.error("alGetSourcei called with an invalid source");
 #endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
+
+    // Being that we have no way to receive end events from buffer nodes,
+    // we currently proccess and update a source's buffer queue every
+    // ~QUEUE_INTERVAL milliseconds. However, this interval is not precise,
+    // so we also forcefully update the source when alGetSourcei is queried
+    // to aid in the common scenario of application calling alGetSourcei(AL_BUFFERS_PROCESSED)
+    // to recycle buffers.
+    _updateSource(src);
+
     switch (param) {
     case 0x202 /* AL_SOURCE_RELATIVE */:
-      // Always return 1
-      {{{ makeSetValue('value', '0', '1', 'i32') }}};
+      {{{ makeSetValue('value', '0', 'src.panner ? 1 : 0', 'i32') }}};
       break;
     case 0x1009 /* AL_BUFFER */:
-      if (AL.currentContext.src[source - 1].buffer == null) {
+      if (!src.queue.length) {
         {{{ makeSetValue('value', '0', '0', 'i32') }}};
       } else {
-        var buf = AL.currentContext.src[source - 1].buffer;
+        // Find the first unprocessed buffer.
+        var buffer = src.queue[src.buffersPlayed].buffer;
+        // Return its index.
         for (var i = 0; i < AL.currentContext.buf.length; ++i) {
-          if (buf == AL.currentContext.buf[i].buf) {
+          if (buffer == AL.currentContext.buf[i]) {
             {{{ makeSetValue('value', '0', 'i+1', 'i32') }}};
             return;
           }
@@ -508,32 +777,79 @@ var LibraryOpenAL = {
       }
       break;
     case 0x1010 /* AL_SOURCE_STATE */:
-      if ("src" in AL.currentContext.src[source - 1]) {
-        {{{ makeSetValue('value', '0', '0x1012', 'i32') }}} /* AL_PLAYING */;
-      } else if (AL.currentContext.src[source - 1].paused) {
-        {{{ makeSetValue('value', '0', '0x1013', 'i32') }}} /* AL_PAUSED */;
-      } else if (AL.currentContext.src[source - 1].playTime == -1) {
-        {{{ makeSetValue('value', '0', '0x1011', 'i32') }}} /* AL_INITIAL */;
-      } else {
-        {{{ makeSetValue('value', '0', '0x1014', 'i32') }}} /* AL_STOPPED */;
-      }
+      {{{ makeSetValue('value', '0', 'src.state', 'i32') }}};
       break;
     case 0x1015 /* AL_BUFFERS_QUEUED */:
-      if (AL.currentContext.src[source - 1].buffer) {
-        {{{ makeSetValue('value', '0', '1', 'i32') }}}
-      } else {
+      {{{ makeSetValue('value', '0', 'src.queue.length', 'i32') }}}
+      break;
+    case 0x1016 /* AL_BUFFERS_PROCESSED */:
+      if (src.loop) {
         {{{ makeSetValue('value', '0', '0', 'i32') }}}
+      } else {
+        {{{ makeSetValue('value', '0', 'src.buffersPlayed', 'i32') }}}
       }
       break;
-    case 0x1016 /* AL_BUFFERS_PROCESSED */:
-      // Always return 1
-      {{{ makeSetValue('value', '0', '1', 'i32') }}}
+    default:
+      AL.currentContext.err = 0xA002 /* AL_INVALID_ENUM */;
+      break;
+    }
+  },
+
+  alGetSourcef: function(source, param, value) {
+    if (!AL.currentContext) {
+#if OPENAL_DEBUG
+      console.error("alGetSourcef called without a valid context");
+#endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
+      return;
+    }
+    var src = AL.currentContext.src[source - 1];
+    if (!src) {
+#if OPENAL_DEBUG
+      console.error("alGetSourcef called with an invalid source");
+#endif
+      AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
+      return;
+    }
+    switch (param) {
+    // case 0x1003 /* AL_PITCH */:
+    //   break;
+    case 0x100A /* AL_GAIN */:
+      {{{ makeSetValue('value', '0', 'src.gain.gain.value', 'float') }}}
+      break;
+    // case 0x100D /* AL_MIN_GAIN */:
+    //   break;
+    // case 0x100E /* AL_MAX_GAIN */:
+    //   break;
+    case 0x1023 /* AL_MAX_DISTANCE */:
+      {{{ makeSetValue('value', '0', 'src.maxDistance', 'float') }}}
+      break;
+    case 0x1021 /* AL_ROLLOFF_FACTOR */:
+      {{{ makeSetValue('value', '0', 'src.rolloffFactor', 'float') }}}
+      break;
+    // case 0x1022 /* AL_CONE_OUTER_GAIN */:
+    //   break;
+    // case 0x1001 /* AL_CONE_INNER_ANGLE */:
+    //   break;
+    // case 0x1002 /* AL_CONE_OUTER_ANGLE */:
+    //   break;
+    case 0x1020 /* AL_REFERENCE_DISTANCE */:
+      {{{ makeSetValue('value', '0', 'src.refDistance', 'float') }}}
+      break;
+    // case 0x1024 /* AL_SEC_OFFSET */:
+    //   break;
+    // case 0x1025 /* AL_SAMPLE_OFFSET */:
+    //   break;
+    // case 0x1026 /* AL_BYTE_OFFSET */:
+    //   break;
+    default:
+      AL.currentContext.err = 0xA002 /* AL_INVALID_ENUM */;
       break;
     }
   },
 
   alDistanceModel: function(model) {
-    if (model != 0 /* AL_NONE */) {
+    if (model !== 0 /* AL_NONE */) {
 #if OPENAL_DEBUG
       console.log("Only alDistanceModel(AL_NONE) is currently supported");
 #endif
@@ -545,6 +861,7 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alListenerfv called without a valid context");
 #endif
+      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     switch (param) {
@@ -576,6 +893,7 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.log("alListenerfv with param " + param + " not implemented yet");
 #endif
+      AL.currentContext.err = 0xA002 /* AL_INVALID_ENUM */;
       break;
     }
   },
@@ -588,13 +906,27 @@ var LibraryOpenAL = {
     return 0;
   },
 
+  alGetString: function (param) {
+    return allocate(intArrayFromString('NA'), 'i8', ALLOC_NORMAL);
+  },
+
   alGetProcAddress: function(fname) {
     return 0;
   },
 
+  alcGetString: function (param) {
+    return allocate(intArrayFromString('NA'), 'i8', ALLOC_NORMAL);
+  },
+
   alcGetProcAddress: function(device, fname) {
     return 0;
   },
+
+  alDopplerFactor: function(value) {
+  },
+
+  alDopplerVelocity: function(value) {
+  }
 };
 
 autoAddDeps(LibraryOpenAL, '$AL');
diff --git a/src/library_sdl.js b/src/library_sdl.js
index 4477e457..80c7ac07 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -1238,61 +1238,133 @@ var LibrarySDL = {
     return flags; // We support JPG, PNG, TIF because browsers do
   },
 
-  IMG_Load_RW__deps: ['SDL_LockSurface'],
-  IMG_Load_RW: function(rwopsID, freesrc) {
-    var rwops = SDL.rwops[rwopsID];
+  IMG_Load_RW__deps: ['SDL_LockSurface', 'SDL_FreeRW'],
+  IMG_Load_RW: function(rwopsID, freeSrc) {
+    try {
+      // stb_image integration support
+      var cleanup = function() {
+        if (rwops && freeSrc) _SDL_FreeRW(rwopsID);
+      };
+      function addCleanup(func) {
+        var old = cleanup;
+        cleanup = function() {
+          old();
+          func();
+        }
+      }
+      function callStbImage(func, params) {
+        var x = Module['_malloc']({{{ QUANTUM_SIZE }}});
+        var y = Module['_malloc']({{{ QUANTUM_SIZE }}});
+        var comp = Module['_malloc']({{{ QUANTUM_SIZE }}});
+        addCleanup(function() {
+          Module['_free'](x);
+          Module['_free'](y);
+          Module['_free'](comp);
+          if (data) Module['_stbi_image_free'](data);
+        });
+        var data = Module['_' + func].apply(null, params.concat([x, y, comp, 0]));
+        if (!data) return null;
+        return {
+          rawData: true,
+          data: data,
+          width: {{{ makeGetValue('x', 0, 'i32') }}},
+          height: {{{ makeGetValue('y', 0, 'i32') }}},
+          size: {{{ makeGetValue('x', 0, 'i32') }}} * {{{ makeGetValue('y', 0, 'i32') }}} * {{{ makeGetValue('comp', 0, 'i32') }}},
+          bpp: {{{ makeGetValue('comp', 0, 'i32') }}}
+        };
+      }
 
-    if (rwops === undefined) {
-      return 0;
-    }
+      var rwops = SDL.rwops[rwopsID];
+      if (rwops === undefined) {
+        return 0;
+      }
 
-    var filename = rwops.filename;
-    
-    if (filename === undefined) {
-      Runtime.warnOnce('Only file names that have been preloaded are supported for IMG_Load_RW.');
-      // TODO. Support loading image data from embedded files, similarly to Mix_LoadWAV_RW
-      // TODO. Support loading image data from byte arrays, similarly to Mix_LoadWAV_RW
-      return 0;
-    }
-    
-    filename = FS.standardizePath(filename);
-    if (filename[0] == '/') {
-      // Convert the path to relative
-      filename = filename.substr(1);
-    }
-    var raw = Module["preloadedImages"][filename];
-    if (!raw) {
-      if (raw === null) Module.printErr('Trying to reuse preloaded image, but freePreloadedMediaOnUse is set!');
-      Runtime.warnOnce('Cannot find preloaded image ' + filename);
-      return 0;
-    }
-    if (Module['freePreloadedMediaOnUse']) {
-      Module["preloadedImages"][filename] = null;
-    }
-    var surf = SDL.makeSurface(raw.width, raw.height, 0, false, 'load:' + filename);
-    var surfData = SDL.surfaces[surf];
-    surfData.ctx.globalCompositeOperation = "copy";
-    surfData.ctx.drawImage(raw, 0, 0, raw.width, raw.height, 0, 0, raw.width, raw.height);
-    surfData.ctx.globalCompositeOperation = "source-over";
-    // XXX SDL does not specify that loaded images must have available pixel data, in fact
-    //     there are cases where you just want to blit them, so you just need the hardware
-    //     accelerated version. However, code everywhere seems to assume that the pixels
-    //     are in fact available, so we retrieve it here. This does add overhead though.
-    _SDL_LockSurface(surf);
-    surfData.locked--; // The surface is not actually locked in this hack
-    if (SDL.GL) {
-      // After getting the pixel data, we can free the canvas and context if we do not need to do 2D canvas blitting
-      surfData.canvas = surfData.ctx = null;
+      var filename = rwops.filename;
+      if (filename === undefined) {
+#if STB_IMAGE
+        var raw = callStbImage('stbi_load_from_memory', [rwops.bytes, rwops.count]);
+        if (!raw) return 0;
+#else
+        Runtime.warnOnce('Only file names that have been preloaded are supported for IMG_Load_RW. Consider using STB_IMAGE=1 if you want synchronous image decoding (see settings.js)');
+        return 0;
+#endif
+      }
+
+      if (!raw) {
+        filename = FS.standardizePath(filename);
+        if (filename[0] == '/') {
+          // Convert the path to relative
+          filename = filename.substr(1);
+        }
+        var raw = Module["preloadedImages"][filename];
+        if (!raw) {
+          if (raw === null) Module.printErr('Trying to reuse preloaded image, but freePreloadedMediaOnUse is set!');
+#if STB_IMAGE
+          var name = Module['_malloc'](filename.length+1);
+          writeStringToMemory(filename, name);
+          addCleanup(function() {
+            Module['_free'](name);
+          });
+          var raw = callStbImage('stbi_load', [name]);
+          if (!raw) return 0;
+#else
+          Runtime.warnOnce('Cannot find preloaded image ' + filename);
+          Runtime.warnOnce('Cannot find preloaded image ' + filename + '. Consider using STB_IMAGE=1 if you want synchronous image decoding (see settings.js)');
+          return 0;
+#endif
+        } else if (Module['freePreloadedMediaOnUse']) {
+          Module["preloadedImages"][filename] = null;
+        }
+      }
+
+      var surf = SDL.makeSurface(raw.width, raw.height, 0, false, 'load:' + filename);
+      var surfData = SDL.surfaces[surf];
+      surfData.ctx.globalCompositeOperation = "copy";
+      if (!raw.rawData) {
+        surfData.ctx.drawImage(raw, 0, 0, raw.width, raw.height, 0, 0, raw.width, raw.height);
+      } else {
+        var imageData = surfData.ctx.getImageData(0, 0, surfData.width, surfData.height);
+        if (raw.bpp == 4) {
+          imageData.data.set({{{ makeHEAPView('U8', 'raw.data', 'raw.data+raw.size') }}});
+        } else if (raw.bpp == 3) {
+          var pixels = raw.size/3;
+          var data = imageData.data;
+          var sourcePtr = raw.data;
+          var destPtr = 0;
+          for (var i = 0; i < pixels; i++) {
+            data[destPtr++] = {{{ makeGetValue('sourcePtr++', 0, 'i8', null, 1) }}};
+            data[destPtr++] = {{{ makeGetValue('sourcePtr++', 0, 'i8', null, 1) }}};
+            data[destPtr++] = {{{ makeGetValue('sourcePtr++', 0, 'i8', null, 1) }}};
+            data[destPtr++] = 255;
+          }
+        } else {
+          Module.printErr('cannot handle bpp ' + raw.bpp);
+          return 0;
+        }
+        surfData.ctx.putImageData(imageData, 0, 0);
+      }
+      surfData.ctx.globalCompositeOperation = "source-over";
+      // XXX SDL does not specify that loaded images must have available pixel data, in fact
+      //     there are cases where you just want to blit them, so you just need the hardware
+      //     accelerated version. However, code everywhere seems to assume that the pixels
+      //     are in fact available, so we retrieve it here. This does add overhead though.
+      _SDL_LockSurface(surf);
+      surfData.locked--; // The surface is not actually locked in this hack
+      if (SDL.GL) {
+        // After getting the pixel data, we can free the canvas and context if we do not need to do 2D canvas blitting
+        surfData.canvas = surfData.ctx = null;
+      }
+      return surf;
+    } finally {
+      cleanup();
     }
-    return surf;
   },
   SDL_LoadBMP: 'IMG_Load',
   SDL_LoadBMP_RW: 'IMG_Load_RW',
-  IMG_Load__deps: ['IMG_Load_RW', 'SDL_RWFromFile', 'SDL_FreeRW'],
+  IMG_Load__deps: ['IMG_Load_RW', 'SDL_RWFromFile'],
   IMG_Load: function(filename){
     var rwops = _SDL_RWFromFile(filename);
-    var result = _IMG_Load_RW(rwops);
-    _SDL_FreeRW(rwops);
+    var result = _IMG_Load_RW(rwops, 1);
     return result;
   },
 
@@ -2055,11 +2127,13 @@ var LibrarySDL = {
   // Misc
 
   SDL_InitSubSystem: function(flags) { return 0 },
+
   SDL_RWFromConstMem: function(mem, size) {
     var id = SDL.rwops.length; // TODO: recycle ids when they are null
     SDL.rwops.push({ bytes: mem, count: size });
     return id;
   },
+  SDL_RWFromMem: 'SDL_RWFromConstMem',
 
   SDL_RWFromFile: function(_name, mode) {
     var id = SDL.rwops.length; // TODO: recycle ids when they are null
diff --git a/src/postamble.js b/src/postamble.js
index 49fd9b3e..25a50bfc 100644
--- a/src/postamble.js
+++ b/src/postamble.js
@@ -1,9 +1,12 @@
 
 // === Auto-generated postamble setup entry stuff ===
 
-Module['callMain'] = function callMain(args) {
+var initialStackTop;
+var inMain;
+
+Module['callMain'] = Module.callMain = function callMain(args) {
   assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
-  assert(!Module['preRun'] || Module['preRun'].length == 0, 'cannot call main when preRun functions remain to be called');
+  assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
 
   args = args || [];
 
@@ -28,29 +31,37 @@ Module['callMain'] = function callMain(args) {
   var start = Date.now();
 #endif
 
-  var ret;
+  initialStackTop = STACKTOP;
+  inMain = true;
 
-  var initialStackTop = STACKTOP;
+  var ret;
   try {
     ret = Module['_main'](argc, argv, 0);
   }
   catch(e) {
-    if (e.name == 'ExitStatus') {
-      return e.status;
+    if (e && typeof e == 'object' && e.type == 'ExitStatus') {
+      // exit() throws this once it's done to make sure execution
+      // has been stopped completely
+      Module.print('Exit Status: ' + e.value);
+      return e.value;
     } else if (e == 'SimulateInfiniteLoop') {
+      // running an evented main loop, don't immediately exit
       Module['noExitRuntime'] = true;
     } else {
       throw e;
     }
   } finally {
-    STACKTOP = initialStackTop;
+    inMain = false;
   }
 
 #if BENCHMARK
   Module.realPrint('main() took ' + (Date.now() - start) + ' milliseconds');
 #endif
 
-  return ret;
+  // if we're not running an evented main loop, it's time to exit
+  if (!Module['noExitRuntime']) {
+    exit(ret);
+  }
 }
 
 {{GLOBAL_VARS}}
@@ -60,20 +71,14 @@ function run(args) {
 
   if (runDependencies > 0) {
     Module.printErr('run() called, but dependencies remain, so not running');
-    return 0;
+    return;
   }
 
-  if (Module['preRun']) {
-    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
-    var toRun = Module['preRun'];
-    Module['preRun'] = [];
-    for (var i = toRun.length-1; i >= 0; i--) {
-      toRun[i]();
-    }
-    if (runDependencies > 0) {
-      // a preRun added a dependency, run will be called later
-      return 0;
-    }
+  preRun();
+
+  if (runDependencies > 0) {
+    // a preRun added a dependency, run will be called later
+    return;
   }
 
   function doRun() {
@@ -81,21 +86,12 @@ function run(args) {
 
     preMain();
 
-    var ret = 0;
     calledRun = true;
     if (Module['_main'] && shouldRunNow) {
-      ret = Module['callMain'](args);
-      if (!Module['noExitRuntime']) {
-        exitRuntime();
-      }
-    }
-    if (Module['postRun']) {
-      if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
-      while (Module['postRun'].length > 0) {
-        Module['postRun'].pop()();
-      }
+      Module['callMain'](args);
     }
-    return ret;
+
+    postRun();
   }
 
   if (Module['setStatus']) {
@@ -106,13 +102,43 @@ function run(args) {
       }, 1);
       if (!ABORT) doRun();
     }, 1);
-    return 0;
   } else {
-    return doRun();
+    doRun();
   }
 }
 Module['run'] = Module.run = run;
 
+function exit(status) {
+  ABORT = true;
+  STACKTOP = initialStackTop;
+
+  // TODO call externally added 'exit' callbacks with the status code.
+  // It'd be nice to provide the same interface for all Module events (e.g.
+  // prerun, premain, postmain). Perhaps an EventEmitter so we can do:
+  // Module.on('exit', function (status) {});
+
+  // exit the runtime
+  exitRuntime();
+
+  if (inMain) {
+    // if we're still inside the callMain's try/catch, we need to throw an
+    // exception in order to immediately terminate execution.
+    throw { type: 'ExitStatus', value: status };
+  }
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+  if (text) {
+    Module.print(text);
+  }
+
+  ABORT = true;
+
+  throw 'abort() at ' + (new Error().stack);
+}
+Module['abort'] = Module.abort = abort;
+
 // {{PRE_RUN_ADDITIONS}}
 
 if (Module['preInit']) {
diff --git a/src/preamble.js b/src/preamble.js
index 218e0388..2955c885 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -242,12 +242,6 @@ var tempI64, tempI64b;
 var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
 #endif
 
-function abort(text) {
-  Module.print(text + ':\n' + (new Error).stack);
-  ABORT = true;
-  throw "Assertion: " + text;
-}
-
 function assert(condition, text) {
   if (!condition) {
     abort('Assertion failed: ' + text);
@@ -711,24 +705,75 @@ function callRuntimeCallbacks(callbacks) {
   }
 }
 
-var __ATINIT__ = []; // functions called during startup
-var __ATMAIN__ = []; // functions called when main() is to be run
-var __ATEXIT__ = []; // functions called during shutdown
+var __ATPRERUN__  = []; // functions called before the runtime is initialized
+var __ATINIT__    = []; // functions called during startup
+var __ATMAIN__    = []; // functions called when main() is to be run
+var __ATEXIT__    = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
 
 var runtimeInitialized = false;
 
+function preRun() {
+  // compatibility - merge in anything from Module['preRun'] at this time
+  if (Module['preRun']) {
+    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+    while (Module['preRun'].length) {
+      addOnPreRun(Module['preRun'].shift());
+    }
+  }
+  callRuntimeCallbacks(__ATPRERUN__);
+}
+
 function ensureInitRuntime() {
   if (runtimeInitialized) return;
   runtimeInitialized = true;
   callRuntimeCallbacks(__ATINIT__);
 }
+
 function preMain() {
   callRuntimeCallbacks(__ATMAIN__);
 }
+
 function exitRuntime() {
   callRuntimeCallbacks(__ATEXIT__);
 }
 
+function postRun() {
+  // compatibility - merge in anything from Module['postRun'] at this time
+  if (Module['postRun']) {
+    if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+    while (Module['postRun'].length) {
+      addOnPostRun(Module['postRun'].shift());
+    }
+  }
+  callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+  __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+  __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+  __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+  __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+  __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
 // Tools
 
 // This processes a JS string into a C-line array of numbers, 0-terminated.
@@ -865,12 +910,6 @@ Module['removeRunDependency'] = removeRunDependency;
 Module["preloadedImages"] = {}; // maps url to image data
 Module["preloadedAudios"] = {}; // maps url to audio data
 
-function addPreRun(func) {
-  if (!Module['preRun']) Module['preRun'] = [];
-  else if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
-  Module['preRun'].push(func);
-}
-
 #if PGO
 var PGOMonitor = {
   called: {},
@@ -885,7 +924,7 @@ var PGOMonitor = {
 };
 Module['PGOMonitor'] = PGOMonitor;
 __ATEXIT__.push({ func: function() { PGOMonitor.dump() } });
-addPreRun(function() { addRunDependency('pgo') });
+addOnPreRun(function() { addRunDependency('pgo') });
 #endif
 
 function loadMemoryInitializer(filename) {
@@ -898,7 +937,7 @@ function loadMemoryInitializer(filename) {
   }
 
   // always do this asynchronously, to keep shell and web as similar as possible
-  addPreRun(function() {
+  addOnPreRun(function() {
     if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
       applyData(Module['readBinary'](filename));
     } else {
diff --git a/src/settings.js b/src/settings.js
index 52e4eeb0..87ab820d 100644
--- a/src/settings.js
+++ b/src/settings.js
@@ -194,6 +194,12 @@ var FORCE_GL_EMULATION = 0; // Forces inclusion of full GL emulation code.
 var DISABLE_GL_EMULATION = 0; // Disable inclusion of full GL emulation code. Useful when you don't want emulation
                               // but do need INCLUDE_FULL_LIBRARY or MAIN_MODULE.
 
+var STB_IMAGE = 0; // Enables building of stb-image, a tiny public-domain library for decoding images, allowing
+                   // decoding of images without using the browser's built-in decoders. The benefit is that this
+                   // can be done synchronously, however, it will not be as fast as the browser itself.
+                   // When enabled, stb-image will be used automatically from IMG_Load and IMG_Load_RW. You
+                   // can also call the stbi_* functions directly yourself.
+
 var DISABLE_EXCEPTION_CATCHING = 0; // Disables generating code to actually catch exceptions. If the code you
                                     // are compiling does not actually rely on catching exceptions (but the
                                     // compiler generates code for it, maybe because of stdlibc++ stuff),
@@ -416,880 +422,881 @@ var DEBUG_TAGS_SHOWING = [];
 
 // A cached set of defines, generated from the header files. This
 // lets the emscripten libc (library.js) see the right values.
-// If you the headers or use different ones, you will need to override
-// this.
-var C_DEFINES = {'SI_MESGQ': '5',
-   'M_SQRTPI': '1.77245385091',
-   '_NL_MESSAGES_CODESET': '86',
-   'SIGRTMIN': '27',
-   'math_errhandling': '1',
-   'M_LOG10E': '0.434294481903',
-   '_S_IFMT': '0170000',
-   '_CS_V7_ENV': '20',
-   'USHRT_MAX': '65535',
-   '_SC_XOPEN_LEGACY': '98',
-   'HAVE_STDINT_H': '1',
-   '_SC_XOPEN_VERSION': '106',
-   'F_UNLCK': '3',
-   '_SC_BC_DIM_MAX': '58',
-   'SDL_LOADSO_DLOPEN': '1',
-   'S_IFDIR': '0040000',
-   'HAVE_ALLOCA': '1',
-   '_SC_BARRIERS': '56',
-   '_IFDIR': '0040000',
-   'SDL_JOYSTICK_DINPUT': '1',
-   '_IFLNK': '0120000',
-   '__long_double_t': "<type 'long'>",
-   'DEFFILEMODE': '0000400',
-   'HAVE_SSCANF': '1',
-   '_FCREAT': '512',
-   'HAVE_STRTOLL': '1',
-   'SDL_VIDEO_OPENGL_ES': '1',
-   'O_CREAT': '512',
-   'SHRT_MAX': '32767',
-   'SDL_JOYSTICK_ANDROID': '1',
-   '_SC_NPROCESSORS_CONF': '9',
-   '_XOPEN_ENH_I18N': '1',
-   'F_DUPFD_CLOEXEC': '14',
-   '_CS_POSIX_V6_LP64_OFF64_LIBS': '11',
-   '_POSIX_SHARED_MEMORY_OBJECTS': '200112',
-   'ABDAY_7': '20',
-   'ABDAY_6': '19',
-   'ABDAY_5': '18',
-   'ABDAY_4': '17',
-   'ABDAY_3': '16',
-   'M_PI': '3.14159265359',
+// If you modify the headers or use different ones, you will need
+// to override this.
+var C_DEFINES = {
    'ABDAY_1': '14',
-   '_PC_REC_MIN_XFER_SIZE': '18',
-   '_SC_V6_ILP32_OFFBIG': '93',
-   'SIGSTOP': '17',
-   '_M_LN2': '0.69314718056',
-   'F_UNLKSYS': '4',
-   'PTHREAD_CREATE_JOINABLE': '1',
-   'SDL_VIDEO_OPENGL_GLX': '1',
-   'M_PI_2': '1.57079632679',
-   '_SC_MEMLOCK': '24',
-   'M_PI_4': '0.785398163397',
+   'ABDAY_2': '15',
+   'ABDAY_3': '16',
+   'ABDAY_4': '17',
+   'ABDAY_5': '18',
+   'ABDAY_6': '19',
+   'ABDAY_7': '20',
+   'ABMON_1': '33',
+   'ABMON_10': '42',
+   'ABMON_11': '43',
+   'ABMON_12': '44',
+   'ABMON_2': '34',
+   'ABMON_3': '35',
+   'ABMON_4': '36',
+   'ABMON_5': '37',
+   'ABMON_6': '38',
+   'ABMON_7': '39',
+   'ABMON_8': '40',
+   'ABMON_9': '41',
+   'ACCESSPERMS': '0000400',
+   'AF_INET': '2',
+   'AF_INET6': '6',
+   'ALLPERMS': '0004000',
+   'ALT_DIGITS': '49',
+   'AM_STR': '5',
+   'ARG_MAX': '4096',
+   'AT_EACCESS': '1',
+   'AT_FDCWD': '-2',
+   'AT_REMOVEDIR': '8',
+   'AT_SYMLINK_FOLLOW': '4',
+   'AT_SYMLINK_NOFOLLOW': '2',
+   'CHAR_BIT': '8',
+   'CHAR_MAX': '127',
+   'CHAR_MIN': '-128',
+   'CLK_TCK': '1000',
+   'CLOCKS_PER_SEC': '1000',
+   'CLOCK_ALLOWED': '1',
+   'CLOCK_DISABLED': '0',
+   'CLOCK_DISALLOWED': '0',
+   'CLOCK_ENABLED': '1',
+   'CODESET': '0',
+   'CRNCYSTR': '56',
+   'DAY_1': '7',
+   'DAY_2': '8',
+   'DAY_3': '9',
+   'DAY_4': '10',
+   'DAY_5': '11',
+   'DAY_6': '12',
+   'DAY_7': '13',
+   'DEFFILEMODE': '0000400',
+   'DOMAIN': '1',
+   'D_FMT': '2',
+   'D_MD_ORDER': '57',
+   'D_T_FMT': '1',
+   'EOF': '-1',
+   'ERA': '45',
+   'ERA_D_FMT': '46',
+   'ERA_D_T_FMT': '47',
+   'ERA_T_FMT': '48',
+   'FAPPEND': '8',
+   'FASYNC': '64',
+   'FCREAT': '512',
+   'FDEFER': '32',
+   'FD_CLOEXEC': '1',
+   'FD_SETSIZE': '64',
+   'FEXCL': '2048',
    'FEXLOCK': '256',
-   '_FNDELAY': '16384',
-   'SIGEV_NONE': '1',
-   'SIGWINCH': '28',
-   'UTIME_NOW': '-2',
-   '_SC_THREADS': '42',
-   '__INT_MAX__': '2147483647',
-   '_XBS5_LP64_OFF64': '-1',
-   '_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS': '6',
-   '___int_least32_t_defined': '1',
-   '_POSIX_MAPPED_FILES': '200112',
-   'HAVE_FREE': '1',
-   'M_E': '2.71828182846',
-   'SIGTRAP': '5',
-   '_SC_SS_REPL_MAX': '78',
-   '_PC_SOCK_MAXBUF': '100',
-   '_SC_THREAD_KEYS_MAX': '38',
-   'O_RDWR': '2',
-   '__LARGE64_FILES': '1',
-   '_POSIX_V6_LP64_OFF64': '-1',
-   'HAVE_COSF': '1',
-   '_SC_2_PBS': '113',
+   'FIONREAD': '1',
+   'FLT_EVAL_METHOD': '0',
+   'FMARK': '16',
+   'FNBIO': '4096',
+   'FNDELAY': '16384',
    'FNOCTTY': '32768',
-   '_SC_TRACE_INHERIT': '86',
-   'PTHREAD_PRIO_NONE': '0',
-   '_SC_REGEXP': '72',
-   '_CS_POSIX_V6_LP64_OFF64_CFLAGS': '9',
-   '_SC_DELAYTIMER_MAX': '37',
-   'HAVE_SINF': '1',
-   '_POSIX_RAW_SOCKETS': '200112',
-   '___int64_t_defined': '1',
-   'S_IFREG': '0100000',
-   'SIGCLD': '20',
+   'FNONBIO': '16384',
+   'FOPEN': '-1',
+   'FP_ILOGBNAN': '2147483647',
+   'FP_INFINITE': '1',
+   'FP_NAN': '0',
+   'FP_NORMAL': '4',
+   'FP_SUBNORMAL': '3',
+   'FP_ZERO': '2',
+   'FREAD': '1',
+   'FSHLOCK': '128',
+   'FSYNC': '8192',
+   'FTRUNC': '1024',
+   'FWRITE': '2',
+   'F_CNVT': '12',
+   'F_DUPFD': '0',
+   'F_DUPFD_CLOEXEC': '14',
+   'F_GETFD': '1',
+   'F_GETFL': '3',
+   'F_GETLK': '7',
    'F_GETLK64': '20',
-   '_IFCHR': '0020000',
-   'S_IRWXG': '0000040',
-   'SDL_VIDEO_DRIVER_ANDROID': '1',
-   'POLLHUP': '16',
-   'S_IFMT': '0170000',
-   'RADIXCHAR': '50',
-   'HAVE_UNSETENV': '1',
-   '_S_IEXEC': '0000100',
-   '_SC_XOPEN_CRYPT': '96',
-   'M_LN10': '2.30258509299',
-   'S_IRWXU': '0000400',
-   'OPTIONAL_ARG': '2',
-   '_PC_CHOWN_RESTRICTED': '6',
-   'CRNCYSTR': '56',
-   'SIZEOF_VOIDP': '4',
-   'SCHAR_MAX': '127',
-   'S_BLKSIZE': '1024',
-   'SDL_JOYSTICK_NDS': '1',
-   '_SC_CLK_TCK': '2',
-   'AM_STR': '5',
-   '__BUFSIZ__': '16',
-   'ALT_DIGITS': '49',
-   'HAVE_SIGNAL_H': '1',
-   'HAVE_ATAN': '1',
-   '_NL_CTYPE_MB_CUR_MAX': '85',
-   '_REENT_SIGNAL_SIZE': '24',
-   'SDL_AUDIO_DRIVER_DSOUND': '1',
+   'F_GETOWN': '5',
+   'F_LOCK': '1',
+   'F_OK': '0',
+   'F_RDLCK': '1',
+   'F_RGETLK': '10',
+   'F_RSETLK': '11',
    'F_RSETLKW': '13',
-   'HAVE_STRTOULL': '1',
-   '___int16_t_defined': '1',
-   'SIGXCPU': '24',
-   '_SC_MQ_PRIO_MAX': '14',
-   '_FTRUNC': '1024',
-   '__MACOSX__': '1',
-   'SDL_LOADSO_WINDOWS': '1',
-   'SDL_VIDEO_DRIVER_X11_XINERAMA': '1',
-   'MALLOC_ALIGNMENT': '16',
-   'PTHREAD_CREATE_DETACHED': '0',
-   '_POSIX2_VERSION': '200112',
-   '_O_CREAT': '512',
-   'PM_STR': '6',
-   '_PC_POSIX_SECURITY': '91',
+   'F_SETFD': '2',
+   'F_SETFL': '4',
+   'F_SETLK': '8',
+   'F_SETLK64': '21',
+   'F_SETLKW': '9',
+   'F_SETLKW64': '22',
+   'F_SETOWN': '6',
+   'F_TEST': '3',
+   'F_TLOCK': '2',
+   'F_ULOCK': '0',
+   'F_UNLCK': '3',
+   'F_UNLKSYS': '4',
+   'F_WRLCK': '2',
+   'H8300': '1',
+   'HAVE_ABS': '1',
+   'HAVE_ALLOCA': '1',
+   'HAVE_ALLOCA_H': '1',
+   'HAVE_ATAN': '1',
+   'HAVE_ATAN2': '1',
+   'HAVE_ATOF': '1',
+   'HAVE_ATOI': '1',
+   'HAVE_BCOPY': '1',
+   'HAVE_CALLOC': '1',
+   'HAVE_CEIL': '1',
+   'HAVE_COPYSIGN': '1',
+   'HAVE_COS': '1',
+   'HAVE_COSF': '1',
+   'HAVE_CTYPE_H': '1',
+   'HAVE_FABS': '1',
+   'HAVE_FLOOR': '1',
+   'HAVE_FREE': '1',
+   'HAVE_GCC_ATOMICS': '1',
+   'HAVE_GCC_SYNC_LOCK_TEST_AND_SET': '1',
+   'HAVE_GETENV': '1',
+   'HAVE_INDEX': '1',
    'HAVE_INTTYPES_H': '1',
-   '_SC_2_LOCALEDEF': '112',
-   '_SC_STREAM_MAX': '100',
+   'HAVE_ITOA': '1',
+   'HAVE_LOG': '1',
+   'HAVE_MALLOC': '1',
+   'HAVE_MATH_H': '1',
    'HAVE_MEMCMP': '1',
-   '_CS_POSIX_V7_ILP32_OFF32_LIBS': '3',
-   '_POSIX2_C_BIND': '200112',
-   '_POSIX_VERSION': '200112',
-   'S_IFIFO': '0010000',
-   'SDL_VIDEO_DRIVER_X11_XSCRNSAVER': '1',
-   'SCHED_FIFO': '1',
-   'SDL_HAPTIC_DISABLED': '1',
-   'M_LN2LO': '1.90821492927e-10',
-   'MON_10': '30',
-   '_CS_XBS5_ILP32_OFF32_LIBS': '3',
-   'O_SYNC': '8192',
-   '_CS_POSIX_V6_ILP32_OFFBIG_LIBS': '7',
-   'YESEXPR': '52',
-   '_PC_PATH_MAX': '4',
-   '_SC_SPORADIC_SERVER': '77',
-   'SDL_POWER_UIKIT': '1',
-   '_POSIX_SYNCHRONIZED_IO': '200112',
-   'SIGXFSZ': '25',
-   '_SC_NPROCESSORS_ONLN': '10',
-   '_CS_POSIX_V6_LPBIG_OFFBIG_LIBS': '15',
-   '_PC_MAX_INPUT': '2',
-   'F_TLOCK': '2',
-   'REQUIRED_ARG': '1',
-   '_SC_VERSION': '7',
+   'HAVE_MEMCPY': '1',
+   'HAVE_MEMMOVE': '1',
+   'HAVE_MEMSET': '1',
+   'HAVE_M_PI': '1',
+   'HAVE_NANOSLEEP': '1',
+   'HAVE_POW': '1',
+   'HAVE_PUTENV': '1',
+   'HAVE_QSORT': '1',
+   'HAVE_REALLOC': '1',
+   'HAVE_RINDEX': '1',
+   'HAVE_SCALBN': '1',
+   'HAVE_SETENV': '1',
+   'HAVE_SETJMP': '1',
+   'HAVE_SIGACTION': '1',
+   'HAVE_SIGNAL_H': '1',
+   'HAVE_SIN': '1',
+   'HAVE_SINF': '1',
+   'HAVE_SNPRINTF': '1',
+   'HAVE_SQRT': '1',
+   'HAVE_SSCANF': '1',
+   'HAVE_STDARG_H': '1',
+   'HAVE_STDDEF_H': '1',
+   'HAVE_STDINT_H': '1',
+   'HAVE_STDIO_H': '1',
+   'HAVE_STRCASECMP': '1',
+   'HAVE_STRCHR': '1',
+   'HAVE_STRCMP': '1',
+   'HAVE_STRDUP': '1',
+   'HAVE_STRICMP': '1',
+   'HAVE_STRING_H': '1',
+   'HAVE_STRLCAT': '1',
+   'HAVE_STRLCPY': '1',
+   'HAVE_STRLEN': '1',
+   'HAVE_STRNCASECMP': '1',
+   'HAVE_STRNCMP': '1',
+   'HAVE_STRRCHR': '1',
+   'HAVE_STRSTR': '1',
+   'HAVE_STRTOD': '1',
+   'HAVE_STRTOL': '1',
+   'HAVE_STRTOLL': '1',
+   'HAVE_STRTOUL': '1',
+   'HAVE_STRTOULL': '1',
+   'HAVE_SYSCONF': '1',
+   'HAVE_SYSCTLBYNAME': '1',
+   'HAVE_SYS_TYPES_H': '1',
+   'HAVE_UNSETENV': '1',
+   'HAVE_VSNPRINTF': '1',
+   'HAVE__LTOA': '1',
+   'HAVE__STRICMP': '1',
+   'HAVE__STRLWR': '1',
+   'HAVE__STRNICMP': '1',
+   'HAVE__STRREV': '1',
+   'HAVE__STRUPR': '1',
+   'HAVE__ULTOA': '1',
    'HUGE_VAL': 'inf',
-   'AT_EACCESS': '1',
-   'ABMON_3': '35',
-   'ABMON_2': '34',
-   'ABMON_1': '33',
-   '_SC_THREAD_ROBUST_PRIO_PROTECT': '123',
-   'ABMON_7': '39',
-   'ABMON_6': '38',
-   'ABMON_5': '37',
-   'ABMON_4': '36',
-   'S_IWUSR': '0000200',
-   'ABMON_9': '41',
-   'ABMON_8': '40',
-   'UNDERFLOW': '4',
-   '_SC_AIO_MAX': '35',
-   'ERA': '45',
-   '_CS_XBS5_ILP32_OFFBIG_LIBS': '7',
-   'S_IXUSR': '0000100',
-   '_SC_THREAD_PRIO_INHERIT': '46',
-   '__HPUX__': '1',
-   'M_2_PI': '0.636619772368',
-   '_O_RDWR': '2',
-   '_PC_2_SYMLINKS': '13',
-   'POSIX_FADV_DONTNEED': '135',
-   'SIG_BLOCK': '1',
-   'SDL_VIDEO_RENDER_NDS': '0',
-   '_O_WRONLY': '1',
-   '_CS_XBS5_LP64_OFF64_CFLAGS': '9',
-   '__OS2__': '1',
+   'INT_MAX': '2147483647',
+   'IPPROTO_TCP': '1',
+   'IPPROTO_UDP': '2',
+   'ITIMER_PROF': '2',
+   'ITIMER_REAL': '0',
+   'ITIMER_VIRTUAL': '1',
+   'LACKS_SYS_MMAN_H': '1',
+   'LONG_MAX': '2147483647',
+   'MAC_OS_X_VERSION_10_4': '1040',
+   'MAC_OS_X_VERSION_10_5': '1050',
+   'MAC_OS_X_VERSION_10_6': '1060',
+   'MALLOC_ALIGNMENT': '16',
+   'MATH_ERREXCEPT': '2',
+   'math_errhandling': '1',
+   'MATH_ERRNO': '1',
+   'MAXPATHLEN': '1024',
+   'MB_LEN_MAX': '1',
+   'MON_1': '21',
+   'MON_10': '30',
+   'MON_11': '31',
+   'MON_12': '32',
    'MON_2': '22',
    'MON_3': '23',
-   '_POSIX_PRIORITY_SCHEDULING': '200112',
-   'MON_1': '21',
-   'MON_6': '26',
-   'MON_7': '27',
    'MON_4': '24',
    'MON_5': '25',
-   '_SC_SPAWN': '75',
+   'MON_6': '26',
+   'MON_7': '27',
    'MON_8': '28',
    'MON_9': '29',
-   '_CS_POSIX_V6_ILP32_OFF32_LDFLAGS': '2',
-   '_SC_TRACE_EVENT_NAME_MAX': '85',
-   'SA_SIGINFO': '2',
-   '_FBINARY': '65536',
-   'PTHREAD_PRIO_PROTECT': '2',
-   'POLLERR': '8',
-   'SIGVTALRM': '26',
-   'O_BINARY': '65536',
-   '_REENT_EMERGENCY_SIZE': '25',
-   'S_IEXEC': '0000100',
-   '_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS': '13',
-   'SIGEV_THREAD': '3',
-   'ITIMER_VIRTUAL': '1',
-   'HAVE_ATOI': '1',
-   '_SC_TRACE_SYS_MAX': '89',
-   '_POSIX_NO_TRUNC': '1',
-   'HAVE_ATOF': '1',
-   '__RISCOS__': '1',
-   '_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS': '17',
-   'HAVE_ATAN2': '1',
-   'HAVE_PUTENV': '1',
-   'SDL_AUDIO_DRIVER_ANDROID': '1',
-   'F_SETFL': '4',
-   'HAVE_GCC_ATOMICS': '1',
-   '_CS_POSIX_V7_THREADS_CFLAGS': '18',
-   '_SC_AIO_PRIO_DELTA_MAX': '36',
-   '_POSIX2_C_DEV': '200112',
-   '_SC_MONOTONIC_CLOCK': '69',
-   '_POSIX_THREAD_SPORADIC_SERVER': '1',
-   '_FNOINHERIT': '262144',
-   'SDL_HAPTIC_NDS': '1',
-   '_SC_XOPEN_ENH_I18N': '97',
-   'SIGPROF': '27',
-   'F_SETLKW64': '22',
-   'HAVE__STRREV': '1',
-   '_O_APPEND': '8',
-   '_FDEFER': '32',
-   'SDL_VIDEO_DRIVER_X11_XINPUT': '1',
-   'CLOCK_DISALLOWED': '0',
-   'SDL_VIDEO_DRIVER_X11': '1',
-   '_SC_MEMORY_PROTECTION': '26',
-   'HAVE_STDIO_H': '1',
-   'LONG_MAX': '2147483647',
-   'no_argument': '0',
-   '__NINTENDODS__': '1',
-   'F_OK': '0',
-   'SDL_ASSEMBLY_ROUTINES': '1',
-   'FAPPEND': '8',
-   'SA_RESETHAND': '8',
-   'FREAD': '1',
-   '_SC_SPIN_LOCKS': '76',
-   'SDL_VIDEO_DRIVER_COCOA': '1',
+   'M_1_PI': '0.318309886184',
+   'M_2_PI': '0.636619772368',
+   'M_2_SQRTPI': '1.1283791671',
+   'M_3PI_4': '2.35619449019',
+   'M_E': '2.71828182846',
+   'M_INVLN2': '1.44269504089',
+   'M_IVLN10': '0.434294481903',
+   'M_LN10': '2.30258509299',
+   'M_LN2': '0.69314718056',
    'M_LN2HI': '0.693147180369',
-   '_LIBC_LIMITS_H_': '1',
-   'S_IFSOCK': '0140000',
-   'SDL_AUDIO_DRIVER_COREAUDIO': '1',
-   'HAVE_MALLOC': '1',
-   '_POSIX_DEVCTL_DIRECTION': '1',
-   'ABDAY_2': '15',
-   'HAVE_STRTOL': '1',
-   'SDL_VIDEO_DRIVER_DUMMY': '1',
-   '_PC_LINK_MAX': '0',
-   '_POSIX_THREAD_PRIO_PROTECT': '1',
-   'HAVE_STRTOD': '1',
-   '__DREAMCAST__': '1',
+   'M_LN2LO': '1.90821492927e-10',
+   'M_LOG10E': '0.434294481903',
+   'M_LOG2E': '1.44269504089',
+   'M_LOG2_E': '0.69314718056',
+   'M_PI': '3.14159265359',
+   'M_PI_2': '1.57079632679',
+   'M_PI_4': '0.785398163397',
+   'M_SQRT1_2': '0.707106781187',
+   'M_SQRT2': '1.41421356237',
+   'M_SQRT3': '1.73205080757',
+   'M_SQRTPI': '1.77245385091',
+   'M_TWOPI': '6.28318530718',
+   'NBBY': '8',
+   'NL_ARGMAX': '32',
    'NOEXPR': '53',
-   'FEXCL': '2048',
-   '_SC_FSYNC': '22',
-   '_SC_GETGR_R_SIZE_MAX': '50',
-   '_POSIX_THREAD_PROCESS_SHARED': '200112',
-   'HAVE_QSORT': '1',
-   '_ATEXIT_SIZE': '32',
-   '_SC_TRACE_NAME_MAX': '88',
-   '_SC_BC_BASE_MAX': '57',
-   '__WIN32__': '1',
-   '_LIMITS_H': '1',
-   'PTHREAD_STACK_MIN': '200',
+   'NOSTR': '55',
+   'NO_ARG': '0',
+   'no_argument': '0',
+   'NSIG': '32',
+   'NULL': '0',
+   'OPTIONAL_ARG': '2',
+   'optional_argument': '2',
+   'OPT_ARG': '2',
+   'OVERFLOW': '3',
+   'O_ACCMODE': '3',
    'O_APPEND': '8',
-   '_CS_XBS5_LP64_OFF64_LINTFLAGS': '12',
-   '_SC_XOPEN_STREAMS': '104',
-   'HAVE_CALLOC': '1',
-   'HAVE_CTYPE_H': '1',
-   '_SC_GETPW_R_SIZE_MAX': '51',
-   '_POSIX_ASYNCHRONOUS_IO': '1',
-   'UCHAR_MAX': '255',
-   '__BSDI__': '1',
-   '_SC_PAGE_SIZE': '8',
-   'SDL_THREADS_DISABLED': '1',
-   '_SC_XBS5_ILP32_OFFBIG': '93',
-   'S_IFBLK': '0060000',
-   '_S_IFIFO': '0010000',
-   'T_FMT_AMPM': '4',
-   '_POSIX_SEMAPHORES': '200112',
-   'HAVE_SCALBN': '1',
-   '__NETBSD__': '1',
-   'NBBY': '8',
-   'SDL_AUDIO_DRIVER_XAUDIO2': '1',
-   'SIGEMT': '7',
-   '_POSIX_FSYNC': '200112',
-   'F_SETLKW': '9',
-   '_MB_EXTENDED_CHARSETS_WINDOWS': '1',
-   'SIGALRM': '14',
-   'SDL_VIDEO_DRIVER_UIKIT': '1',
-   '___int32_t_defined': '1',
+   'O_BINARY': '65536',
+   'O_CLOEXEC': '262144',
+   'O_CREAT': '512',
+   'O_EXCL': '2048',
+   'O_NOCTTY': '32768',
+   'O_NOINHERIT': '262144',
+   'O_NONBLOCK': '16384',
+   'O_RDONLY': '0',
+   'O_RDWR': '2',
+   'O_SYNC': '8192',
+   'O_TEXT': '131072',
+   'O_TRUNC': '1024',
+   'O_WRONLY': '1',
+   'PATH_MAX': '4096',
+   'PF_INET': '2',
+   'PF_INET6': '6',
+   'PLOSS': '6',
+   'PM_STR': '6',
+   'POLLERR': '8',
+   'POLLHUP': '16',
+   'POLLIN': '1',
    'POLLNVAL': '4',
-   '_SC_OPEN_MAX': '4',
-   'CHAR_BIT': '8',
-   '_N_LISTS': '30',
-   '_SC_2_FORT_RUN': '111',
+   'POLLOUT': '2',
+   'POSIX_FADV_DONTNEED': '135',
+   'PTHREAD_CREATE_DETACHED': '0',
+   'PTHREAD_CREATE_JOINABLE': '1',
+   'PTHREAD_EXPLICIT_SCHED': '2',
+   'PTHREAD_INHERIT_SCHED': '1',
    'PTHREAD_MUTEX_DEFAULT': '3',
-   'HAVE_STDARG_H': '1',
-   '_POSIX_REGEXP': '1',
-   '_SC_RE_DUP_MAX': '73',
+   'PTHREAD_MUTEX_ERRORCHECK': '2',
+   'PTHREAD_MUTEX_NORMAL': '0',
+   'PTHREAD_MUTEX_RECURSIVE': '1',
+   'PTHREAD_PRIO_INHERIT': '1',
+   'PTHREAD_PRIO_NONE': '0',
+   'PTHREAD_PRIO_PROTECT': '2',
    'PTHREAD_PROCESS_PRIVATE': '0',
-   '_S_IFREG': '0100000',
-   '_SC_THREAD_THREADS_MAX': '40',
-   '_SC_THREAD_PRIO_PROTECT': '47',
-   'SDL_THREAD_WINDOWS': '1',
-   '_SC_2_PBS_CHECKPOINT': '115',
-   'M_1_PI': '0.318309886184',
-   '_PC_POSIX_PERMISSIONS': '90',
-   '_SC_TIMERS': '33',
-   'MON_11': '31',
-   'MON_12': '32',
-   'CLOCK_DISABLED': '0',
-   '_SC_XBS5_LPBIG_OFFBIG': '95',
-   '_POSIX_SPIN_LOCKS': '200112',
-   '_FREAD': '1',
-   'HAVE_SYSCONF': '1',
-   '_SC_SHARED_MEMORY_OBJECTS': '199',
-   'F_RDLCK': '1',
-   'F_GETFD': '1',
-   'MAC_OS_X_VERSION_10_4': '1040',
-   'AT_SYMLINK_NOFOLLOW': '2',
-   '_PC_ALLOC_SIZE_MIN': '15',
-   '_POSIX_C_SOURCE': '2',
-   '_SC_READER_WRITER_LOCKS': '71',
-   'HAVE_STRING_H': '1',
-   'SI_USER': '1',
-   '_SC_MEMLOCK_RANGE': '25',
-   '_SC_PRIORITY_SCHEDULING': '101',
-   'optional_argument': '2',
-   'T_FMT': '3',
-   'LACKS_SYS_MMAN_H': '1',
-   'MAC_OS_X_VERSION_10_5': '1050',
-   '_PC_VDISABLE': '8',
-   'SDL_VIDEO_DRIVER_X11_XSHAPE': '1',
-   'THOUSEP': '51',
-   'O_NOINHERIT': '262144',
    'PTHREAD_PROCESS_SHARED': '1',
-   '_SC_TRACE_EVENT_FILTER': '84',
-   'ERA_T_FMT': '48',
-   '_SC_THREAD_ATTR_STACKADDR': '43',
-   '_SC_LOGIN_NAME_MAX': '52',
-   'M_LOG2E': '1.44269504089',
-   'ITIMER_PROF': '2',
-   'HAVE_LOG': '1',
-   '_SC_2_C_BIND': '108',
-   'FNONBIO': '16384',
-   '_PC_NO_TRUNC': '7',
-   'F_RSETLK': '11',
-   '_SC_V7_ILP32_OFF32': '92',
-   '_FAPPEND': '8',
-   'PTHREAD_EXPLICIT_SCHED': '2',
-   '_FNBIO': '4096',
-   'HAVE_SYSCTLBYNAME': '1',
-   'F_CNVT': '12',
-   '_SC_SHELL': '74',
-   '_SC_V6_LP64_OFF64': '94',
+   'PTHREAD_SCOPE_PROCESS': '0',
+   'PTHREAD_SCOPE_SYSTEM': '1',
+   'PTHREAD_STACK_MIN': '200',
+   'RADIXCHAR': '50',
+   'REQUIRED_ARG': '1',
+   'required_argument': '1',
+   'REQ_ARG': '1',
+   'R_OK': '4',
+   'SA_NOCLDSTOP': '1',
+   'SA_NODEFER': '4',
+   'SA_RESETHAND': '8',
+   'SA_SIGINFO': '2',
+   'SCHAR_MAX': '127',
+   'SCHAR_MIN': '-128',
+   'SCHED_FIFO': '1',
    'SCHED_OTHER': '0',
-   '_CS_GNU_LIBC_VERSION': '42',
-   '_SC_SEM_VALUE_MAX': '17',
-   'S_ENFMT': '0002000',
-   '_SC_MQ_OPEN_MAX': '13',
+   'SCHED_RR': '2',
+   'SCHED_SPORADIC': '4',
+   'SDL_ALTIVEC_BLITTERS': '1',
+   'SDL_ASSEMBLY_ROUTINES': '1',
+   'SDL_ASSERT_LEVEL': '1',
+   'SDL_AUDIO_DRIVER_ANDROID': '1',
+   'SDL_AUDIO_DRIVER_COREAUDIO': '1',
+   'SDL_AUDIO_DRIVER_COREAUDIOIPHONE': '1',
+   'SDL_AUDIO_DRIVER_DISK': '1',
+   'SDL_AUDIO_DRIVER_DSOUND': '1',
+   'SDL_AUDIO_DRIVER_DUMMY': '1',
+   'SDL_AUDIO_DRIVER_NDS': '1',
+   'SDL_AUDIO_DRIVER_WINMM': '1',
+   'SDL_AUDIO_DRIVER_XAUDIO2': '1',
+   'SDL_HAPTIC_DINPUT': '1',
+   'SDL_HAPTIC_DISABLED': '1',
+   'SDL_HAPTIC_DUMMY': '1',
+   'SDL_HAPTIC_IOKIT': '1',
+   'SDL_HAPTIC_NDS': '1',
+   'SDL_IPHONE_KEYBOARD': '1',
+   'SDL_IPHONE_MAX_GFORCE': '5.0',
+   'SDL_JOYSTICK_ANDROID': '1',
+   'SDL_JOYSTICK_DINPUT': '1',
    'SDL_JOYSTICK_DISABLED': '1',
-   '_POSIX_ADVISORY_INFO': '200112',
-   'SIGABRT': '6',
-   '_CS_POSIX_V7_ILP32_OFF32_CFLAGS': '1',
-   '_CS_XBS5_ILP32_OFF32_CFLAGS': '1',
-   '_MB_EXTENDED_CHARSETS_ISO': '1',
-   '_SC_HOST_NAME_MAX': '65',
-   '_SC_THREAD_STACK_MIN': '39',
-   '_SC_TIMEOUTS': '82',
-   'POLLOUT': '2',
-   '_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS': '16',
-   '_SC_CHILD_MAX': '1',
-   '__RAND_MAX': '2147483647',
+   'SDL_JOYSTICK_IOKIT': '1',
+   'SDL_JOYSTICK_NDS': '1',
+   'SDL_LOADSO_DISABLED': '1',
+   'SDL_LOADSO_DLOPEN': '1',
+   'SDL_LOADSO_WINDOWS': '1',
+   'SDL_POWER_MACOSX': '1',
+   'SDL_POWER_NINTENDODS': '1',
+   'SDL_POWER_UIKIT': '1',
+   'SDL_POWER_WINDOWS': '1',
+   'SDL_THREADS_DISABLED': '1',
+   'SDL_THREAD_PTHREAD': '1',
+   'SDL_THREAD_PTHREAD_RECURSIVE_MUTEX': '1',
+   'SDL_THREAD_WINDOWS': '1',
+   'SDL_TIMERS_DISABLED': '1',
+   'SDL_TIMER_NDS': '1',
+   'SDL_TIMER_UNIX': '1',
+   'SDL_TIMER_WINCE': '1',
+   'SDL_TIMER_WINDOWS': '1',
+   'SDL_VIDEO_DRIVER_ANDROID': '1',
+   'SDL_VIDEO_DRIVER_COCOA': '1',
+   'SDL_VIDEO_DRIVER_DUMMY': '1',
    'SDL_VIDEO_DRIVER_NDS': '1',
-   '_POSIX_THREAD_ATTR_STACKADDR': '1',
+   'SDL_VIDEO_DRIVER_UIKIT': '1',
+   'SDL_VIDEO_DRIVER_WINDOWS': '1',
+   'SDL_VIDEO_DRIVER_X11': '1',
+   'SDL_VIDEO_DRIVER_X11_XINERAMA': '1',
+   'SDL_VIDEO_DRIVER_X11_XINPUT': '1',
+   'SDL_VIDEO_DRIVER_X11_XRANDR': '1',
+   'SDL_VIDEO_DRIVER_X11_XSCRNSAVER': '1',
+   'SDL_VIDEO_DRIVER_X11_XSHAPE': '1',
+   'SDL_VIDEO_DRIVER_X11_XVIDMODE': '1',
+   'SDL_VIDEO_OPENGL': '1',
+   'SDL_VIDEO_OPENGL_CGL': '1',
+   'SDL_VIDEO_OPENGL_ES': '1',
+   'SDL_VIDEO_OPENGL_GLX': '1',
+   'SDL_VIDEO_OPENGL_WGL': '1',
+   'SDL_VIDEO_RENDER_D3D': '1',
+   'SDL_VIDEO_RENDER_NDS': '0',
+   'SDL_VIDEO_RENDER_OGL': '1',
+   'SDL_VIDEO_RENDER_OGL_ES': '1',
+   'SDL_VIDEO_RENDER_OGL_ES2': '1',
+   'SEEK_CUR': '1',
+   'SEEK_END': '2',
+   'SEEK_SET': '0',
+   'SHRT_MAX': '32767',
+   'SHRT_MIN': '-32768',
+   'SIGABRT': '6',
+   'SIGALRM': '14',
+   'SIGBUS': '10',
+   'SIGCHLD': '20',
+   'SIGCLD': '20',
+   'SIGCONT': '19',
+   'SIGEMT': '7',
+   'SIGEV_NONE': '1',
+   'SIGEV_SIGNAL': '2',
+   'SIGEV_THREAD': '3',
    'SIGFPE': '8',
-   'NL_ARGMAX': '32',
-   '_SC_2_PBS_MESSAGE': '117',
-   'TIMER_ABSTIME': '4',
-   '_NL_CTYPE_CODESET_NAME': '0',
-   '_SC_2_C_DEV': '109',
-   '_SC_TIMER_MAX': '19',
-   'S_IXOTH': '0000001',
-   'FP_ZERO': '2',
-   'SING': '2',
-   'M_INVLN2': '1.44269504089',
-   'SDL_TIMERS_DISABLED': '1',
-   'M_TWOPI': '6.28318530718',
-   '_PC_REC_XFER_ALIGN': '19',
-   '_NL_TIME_DATE_FMT': '84',
-   '_SC_REALTIME_SIGNALS': '29',
-   '_POSIX2_RE_DUP_MAX': '255',
-   'CLOCKS_PER_SEC': '1000',
-   '_READ_WRITE_RETURN_TYPE': "<type 'int'>",
-   'ERA_D_T_FMT': '47',
+   'SIGHUP': '1',
+   'SIGILL': '4',
+   'SIGINT': '2',
+   'SIGIO': '23',
+   'SIGIOT': '6',
+   'SIGKILL': '9',
+   'SIGLOST': '29',
+   'SIGPIPE': '13',
+   'SIGPOLL': '23',
+   'SIGPROF': '27',
+   'SIGPWR': '19',
+   'SIGQUIT': '3',
+   'SIGRTMAX': '31',
+   'SIGRTMIN': '27',
+   'SIGSEGV': '11',
+   'SIGSTOP': '17',
+   'SIGSYS': '12',
+   'SIGTERM': '15',
+   'SIGTRAP': '5',
+   'SIGTSTP': '18',
+   'SIGTTIN': '21',
+   'SIGTTOU': '22',
+   'SIGURG': '16',
+   'SIGUSR1': '30',
+   'SIGUSR2': '31',
+   'SIGVTALRM': '26',
+   'SIGWINCH': '28',
+   'SIGXCPU': '24',
+   'SIGXFSZ': '25',
+   'SIG_BLOCK': '1',
+   'SIG_SETMASK': '0',
    'SIG_UNBLOCK': '2',
-   '_CS_XBS5_ILP32_OFFBIG_LDFLAGS': '6',
-   '_FSHLOCK': '128',
-   'CLK_TCK': '1000',
-   'D_FMT': '2',
-   'SDL_VIDEO_OPENGL_CGL': '1',
-   '_POSIX_SPAWN': '1',
-   '_XBS5_ILP32_OFF32': '-1',
-   '_SC_THREAD_PRIO_CEILING': '47',
-   'SCHED_SPORADIC': '4',
-   '_PC_ASYNC_IO': '9',
+   'SING': '2',
+   'SIZEOF_VOIDP': '4',
+   'SI_ASYNCIO': '4',
+   'SI_MESGQ': '5',
+   'SI_QUEUE': '2',
    'SI_TIMER': '3',
-   'DAY_2': '8',
-   'DAY_3': '9',
-   'DAY_1': '7',
-   'DAY_6': '12',
-   'DAY_7': '13',
-   'DAY_4': '10',
-   'DAY_5': '11',
-   'F_GETFL': '3',
-   'HAVE_STRNCMP': '1',
-   'AT_REMOVEDIR': '8',
-   'SDL_THREAD_PTHREAD_RECURSIVE_MUTEX': '1',
-   'PATH_MAX': '4096',
-   '_POSIX_TIMEOUTS': '1',
-   '_SC_MAPPED_FILES': '23',
-   '__IRIX__': '1',
-   'HAVE_INDEX': '1',
-   'HAVE__LTOA': '1',
-   '_SC_NGROUPS_MAX': '3',
-   '__QNXNTO__': '1',
-   '_FSYNC': '8192',
-   'MATH_ERRNO': '1',
-   '_POSIX_SAVED_IDS': '1',
-   'SDL_POWER_MACOSX': '1',
-   '_SC_SEMAPHORES': '30',
-   '__FILENAME_MAX__': '255',
-   'SIGTSTP': '18',
-   'F_ULOCK': '0',
-   'HAVE_COS': '1',
-   '__LONG_MAX__': '2147483647',
-   'F_WRLCK': '2',
-   '_POSIX_JOB_CONTROL': '1',
-   'FLT_EVAL_METHOD': '0',
-   '_XOPEN_SHM': '1',
-   '_POSIX_CHOWN_RESTRICTED': '1',
-   'F_SETLK64': '21',
-   '_SC_TRACE_LOG': '87',
-   'HAVE_ITOA': '1',
-   'SIGILL': '4',
-   '_FNONBLOCK': '16384',
-   '__OPENBSD__': '1',
-   '_POSIX_TIMERS': '1',
-   'FNDELAY': '16384',
-   'FD_CLOEXEC': '1',
-   'POLLIN': '1',
+   'SI_USER': '1',
+   'SOCK_DGRAM': '20',
+   'SOCK_STREAM': '200',
+   'STDC_HEADERS': '1',
+   'STDERR_FILENO': '2',
+   'STDIN_FILENO': '0',
+   'STDOUT_FILENO': '1',
+   'S_BLKSIZE': '1024',
+   'S_ENFMT': '0002000',
+   'S_IEXEC': '0000100',
+   'S_IFBLK': '0060000',
+   'S_IFCHR': '0020000',
+   'S_IFDIR': '0040000',
+   'S_IFIFO': '0010000',
+   'S_IFLNK': '0120000',
+   'S_IFMT': '0170000',
+   'S_IFREG': '0100000',
+   'S_IFSOCK': '0140000',
+   'S_IREAD': '0000400',
+   'S_IRGRP': '0000040',
+   'S_IROTH': '0000004',
+   'S_IRUSR': '0000400',
+   'S_IRWXG': '0000040',
+   'S_IRWXO': '0000004',
+   'S_IRWXU': '0000400',
+   'S_ISGID': '0002000',
+   'S_ISUID': '0004000',
+   'S_ISVTX': '0001000',
+   'S_IWGRP': '0000020',
+   'S_IWOTH': '0000002',
+   'S_IWRITE': '0000200',
+   'S_IWUSR': '0000200',
+   'S_IXGRP': '0000010',
+   'S_IXOTH': '0000001',
+   'S_IXUSR': '0000100',
+   'THOUSEP': '51',
+   'TIMER_ABSTIME': '4',
+   'TLOSS': '5',
+   'T_FMT': '3',
+   'T_FMT_AMPM': '4',
+   'UCHAR_MAX': '255',
+   'UINT_MAX': '2147483647',
+   'ULONG_MAX': '2147483647',
+   'UNDERFLOW': '4',
+   'USHRT_MAX': '65535',
+   'UTIME_NOW': '-2',
+   'UTIME_OMIT': '-1',
+   'W_OK': '2',
+   'X_OK': '1',
+   'YESEXPR': '52',
+   'YESSTR': '54',
+   '_ATEXIT_SIZE': '32',
+   '_CLOCKS_PER_SEC_': '1000',
+   '_CS_GNU_LIBC_VERSION': '42',
+   '_CS_GNU_LIBPTHREAD_VERSION': '43',
+   '_CS_PATH': '0',
+   '_CS_POSIX_V6_ILP32_OFF32_CFLAGS': '1',
+   '_CS_POSIX_V6_ILP32_OFF32_LDFLAGS': '2',
+   '_CS_POSIX_V6_ILP32_OFF32_LIBS': '3',
+   '_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS': '5',
+   '_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS': '6',
+   '_CS_POSIX_V6_ILP32_OFFBIG_LIBS': '7',
+   '_CS_POSIX_V6_LP64_OFF64_CFLAGS': '9',
+   '_CS_POSIX_V6_LP64_OFF64_LDFLAGS': '10',
+   '_CS_POSIX_V6_LP64_OFF64_LIBS': '11',
+   '_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS': '13',
    '_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS': '14',
-   '_POSIX_THREAD_CPUTIME': '1',
-   'F_LOCK': '1',
-   '_FLOAT_ARG': "<type 'float'>",
-   'REQ_ARG': '1',
+   '_CS_POSIX_V6_LPBIG_OFFBIG_LIBS': '15',
+   '_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS': '17',
+   '_CS_POSIX_V7_ILP32_OFF32_CFLAGS': '1',
+   '_CS_POSIX_V7_ILP32_OFF32_LDFLAGS': '2',
+   '_CS_POSIX_V7_ILP32_OFF32_LIBS': '3',
+   '_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS': '5',
+   '_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS': '6',
+   '_CS_POSIX_V7_ILP32_OFFBIG_LIBS': '7',
+   '_CS_POSIX_V7_LP64_OFF64_CFLAGS': '9',
+   '_CS_POSIX_V7_LP64_OFF64_LDFLAGS': '10',
+   '_CS_POSIX_V7_LP64_OFF64_LIBS': '11',
+   '_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS': '13',
+   '_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS': '14',
+   '_CS_POSIX_V7_LPBIG_OFFBIG_LIBS': '15',
+   '_CS_POSIX_V7_THREADS_CFLAGS': '18',
+   '_CS_POSIX_V7_THREADS_LDFLAGS': '19',
+   '_CS_POSIX_V7_WIDTH_RESTRICTED_ENVS': '17',
+   '_CS_V7_ENV': '20',
+   '_CS_XBS5_ILP32_OFF32_CFLAGS': '1',
+   '_CS_XBS5_ILP32_OFF32_LDFLAGS': '2',
+   '_CS_XBS5_ILP32_OFF32_LIBS': '3',
    '_CS_XBS5_ILP32_OFF32_LINTFLAGS': '4',
-   '_SC_THREAD_DESTRUCTOR_ITERATIONS': '53',
-   'M_LN2': '0.69314718056',
-   'UINT_MAX': '2147483647',
-   'HAVE_STRDUP': '1',
-   'SIG_SETMASK': '0',
-   '_SC_BC_STRING_MAX': '60',
+   '_CS_XBS5_ILP32_OFFBIG_CFLAGS': '5',
+   '_CS_XBS5_ILP32_OFFBIG_LDFLAGS': '6',
+   '_CS_XBS5_ILP32_OFFBIG_LIBS': '7',
+   '_CS_XBS5_ILP32_OFFBIG_LINTFLAGS': '8',
+   '_CS_XBS5_LP64_OFF64_CFLAGS': '9',
+   '_CS_XBS5_LP64_OFF64_LDFLAGS': '10',
+   '_CS_XBS5_LP64_OFF64_LIBS': '11',
+   '_CS_XBS5_LP64_OFF64_LINTFLAGS': '12',
+   '_CS_XBS5_LPBIG_OFFBIG_CFLAGS': '13',
+   '_CS_XBS5_LPBIG_OFFBIG_LDFLAGS': '14',
    '_CS_XBS5_LPBIG_OFFBIG_LIBS': '15',
-   '_SC_XOPEN_UUCP': '124',
-   '_SC_2_SW_DEV': '119',
-   'FDEFER': '32',
-   'FP_NAN': '0',
-   'F_SETOWN': '6',
-   'SDL_LOADSO_DISABLED': '1',
-   'CHAR_MIN': '-128',
-   'PTHREAD_SCOPE_SYSTEM': '1',
-   'HAVE_SETENV': '1',
-   'HAVE_STRNCASECMP': '1',
-   '_POSIX_V6_LPBIG_OFFBIG': '-1',
-   '_S_IWRITE': '0000200',
-   '_S_IFDIR': '0040000',
-   '_SC_ARG_MAX': '0',
-   '_SC_THREAD_PRIORITY_SCHEDULING': '45',
-   'F_GETLK': '7',
-   'SIGTTIN': '21',
-   '_CS_POSIX_V7_WIDTH_RESTRICTED_ENVS': '17',
-   '_POSIX_SPORADIC_SERVER': '1',
-   '_SC_THREAD_CPUTIME': '80',
-   '_POSIX_V6_ILP32_OFF32': '-1',
-   '_CS_POSIX_V7_ILP32_OFFBIG_LIBS': '7',
-   '_CS_POSIX_V6_ILP32_OFF32_LIBS': '3',
-   '_SC_SYNCHRONIZED_IO': '32',
-   '_UNIX98_THREAD_MUTEX_ATTRIBUTES': '1',
-   '_POSIX_REALTIME_SIGNALS': '200112',
-   '__SIGLASTNOTRT': '31',
-   'ERA_D_FMT': '46',
-   'HAVE_RINDEX': '1',
-   'OPT_ARG': '2',
-   'SDL_HAPTIC_IOKIT': '1',
+   '_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS': '16',
+   '_DATE_FMT': '84',
+   '_FAPPEND': '8',
    '_FASYNC': '64',
-   '_CS_POSIX_V6_ILP32_OFF32_CFLAGS': '1',
-   'NOSTR': '55',
-   '_POSIX_MONOTONIC_CLOCK': '200112',
-   'SIGPOLL': '23',
-   'S_ISGID': '0002000',
-   'FP_INFINITE': '1',
-   'ULONG_MAX': '2147483647',
-   '__SIGFIRSTNOTRT': '1',
-   'AT_SYMLINK_FOLLOW': '4',
-   'FSYNC': '8192',
-   '__USE_XOPEN2K': '1',
-   'SDL_VIDEO_RENDER_OGL_ES': '1',
-   '_CS_XBS5_ILP32_OFFBIG_CFLAGS': '5',
-   '_IFSOCK': '0140000',
+   '_FBINARY': '65536',
+   '_FCREAT': '512',
+   '_FDEFER': '32',
+   '_FEXCL': '2048',
+   '_FEXLOCK': '256',
+   '_FLOAT_ARG': "<type 'float'>",
+   '_FMARK': '16',
+   '_FNBIO': '4096',
+   '_FNDELAY': '16384',
+   '_FNOCTTY': '32768',
+   '_FNOINHERIT': '262144',
+   '_FNONBLOCK': '16384',
+   '_FOPEN': '-1',
+   '_FREAD': '1',
+   '_FSHLOCK': '128',
+   '_FSYNC': '8192',
+   '_FTEXT': '131072',
+   '_FTRUNC': '1024',
+   '_FWRITE': '2',
+   '_IFBLK': '0060000',
+   '_IFCHR': '0020000',
+   '_IFDIR': '0040000',
    '_IFIFO': '0010000',
-   'ARG_MAX': '4096',
-   'SIGPIPE': '13',
-   'HAVE__ULTOA': '1',
+   '_IFLNK': '0120000',
+   '_IFMT': '0170000',
+   '_IFREG': '0100000',
+   '_IFSOCK': '0140000',
+   '_LARGEFILE64_SOURCE': '1',
+   '_LIBC_LIMITS_H_': '1',
+   '_LIMITS_H': '1',
+   '_LONG_LONG_TYPE': "<type 'long'>",
+   '_MB_EXTENDED_CHARSETS_ISO': '1',
+   '_MB_EXTENDED_CHARSETS_WINDOWS': '1',
+   '_M_LN2': '0.69314718056',
+   '_NL_CTYPE_CODESET_NAME': '0',
+   '_NL_CTYPE_MB_CUR_MAX': '85',
+   '_NL_MESSAGES_CODESET': '86',
+   '_NL_TIME_DATE_FMT': '84',
+   '_NULL': '0',
+   '_N_LISTS': '30',
+   '_O_APPEND': '8',
+   '_O_BINARY': '65536',
+   '_O_CREAT': '512',
    '_O_EXCL': '2048',
-   'O_TRUNC': '1024',
-   'O_TEXT': '131072',
-   '_POSIX_THREAD_PRIO_INHERIT': '1',
-   '_XBS5_ILP32_OFFBIG': '1',
-   'HAVE_MEMMOVE': '1',
-   'STDERR_FILENO': '2',
-   '_CS_XBS5_LPBIG_OFFBIG_CFLAGS': '13',
-   '__LINUX__': '1',
-   'PLOSS': '6',
-   'S_IRWXO': '0000004',
-   '_SC_V7_LP64_OFF64': '94',
    '_O_NOINHERIT': '262144',
-   'D_MD_ORDER': '57',
-   '_IFMT': '0170000',
-   '_SC_SYMLOOP_MAX': '79',
-   'MB_LEN_MAX': '1',
-   'SDL_TIMER_WINDOWS': '1',
-   '_SC_XOPEN_UNIX': '105',
-   'M_IVLN10': '0.434294481903',
-   'ALLPERMS': '0004000',
-   'HAVE_STRSTR': '1',
-   '__BEOS__': '1',
-   'HAVE_GCC_SYNC_LOCK_TEST_AND_SET': '1',
-   'F_SETFD': '2',
-   'SIGUSR1': '30',
-   'HAVE_SIN': '1',
-   'SDL_VIDEO_DRIVER_X11_XRANDR': '1',
-   'MAC_OS_X_VERSION_10_6': '1060',
-   '___int8_t_defined': '1',
-   'SIGKILL': '9',
-   '_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS': '5',
-   'PTHREAD_MUTEX_RECURSIVE': '1',
-   'SIGSEGV': '11',
-   'M_LOG2_E': '0.69314718056',
-   'FWRITE': '2',
-   '_FEXCL': '2048',
-   'SIGINT': '2',
-   'HAVE_STRRCHR': '1',
-   'H8300': '1',
-   '_POSIX_MEMORY_PROTECTION': '200112',
-   'FP_ILOGBNAN': '2147483647',
-   '_SC_V7_LPBIG_OFFBIG': '95',
-   '_SC_CLOCK_SELECTION': '61',
+   '_O_RAW': '65536',
+   '_O_RDONLY': '0',
+   '_O_RDWR': '2',
+   '_O_TEXT': '131072',
+   '_O_TRUNC': '1024',
+   '_O_WRONLY': '1',
+   '_PC_2_SYMLINKS': '13',
+   '_PC_ALLOC_SIZE_MIN': '15',
+   '_PC_ASYNC_IO': '9',
+   '_PC_CHOWN_RESTRICTED': '6',
+   '_PC_FILESIZEBITS': '12',
+   '_PC_LINK_MAX': '0',
+   '_PC_MAX_CANON': '1',
+   '_PC_MAX_INPUT': '2',
+   '_PC_NAME_MAX': '3',
+   '_PC_NO_TRUNC': '7',
+   '_PC_PATH_MAX': '4',
+   '_PC_PIPE_BUF': '5',
+   '_PC_POSIX_PERMISSIONS': '90',
+   '_PC_POSIX_SECURITY': '91',
    '_PC_PRIO_IO': '10',
-   'M_2_SQRTPI': '1.1283791671',
-   'S_IROTH': '0000004',
-   '_SC_MESSAGE_PASSING': '27',
-   '_SC_V6_LPBIG_OFFBIG': '95',
-   'SDL_AUDIO_DRIVER_DUMMY': '1',
-   'HAVE_MEMCPY': '1',
-   '_SC_EXPR_NEST_MAX': '64',
-   'SDL_TIMER_WINCE': '1',
-   'STDC_HEADERS': '1',
-   '_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS': '5',
-   'S_ISVTX': '0001000',
-   'HAVE_STRLCPY': '1',
-   'UTIME_OMIT': '-1',
-   '_CS_POSIX_V7_THREADS_LDFLAGS': '19',
-   'SDL_POWER_WINDOWS': '1',
-   '_SC_PAGESIZE': '8',
+   '_PC_REC_INCR_XFER_SIZE': '16',
    '_PC_REC_MAX_XFER_SIZE': '17',
-   'SIGIOT': '6',
-   'FASYNC': '64',
-   '_SC_V7_ILP32_OFFBIG': '93',
-   '_RAND48_MULT_0': '58989',
-   '_RAND48_MULT_1': '57068',
-   '_RAND48_MULT_2': '5',
-   '_CS_POSIX_V6_LP64_OFF64_LDFLAGS': '10',
-   'HAVE_STRTOUL': '1',
-   'PTHREAD_MUTEX_NORMAL': '0',
-   '_O_TRUNC': '1024',
-   'W_OK': '2',
-   'O_NONBLOCK': '16384',
-   'R_OK': '4',
-   '_IFBLK': '0060000',
-   'FTRUNC': '1024',
-   '__OSF__': '1',
-   '_SC_XBS5_LP64_OFF64': '94',
-   'STDIN_FILENO': '0',
-   'HAVE_ABS': '1',
-   'SDL_TIMER_NDS': '1',
-   '_CS_POSIX_V7_LPBIG_OFFBIG_LIBS': '15',
-   'SDL_AUDIO_DRIVER_DISK': '1',
-   '_SC_SIGQUEUE_MAX': '18',
-   'M_3PI_4': '2.35619449019',
-   'HAVE_STRCMP': '1',
+   '_PC_REC_MIN_XFER_SIZE': '18',
+   '_PC_REC_XFER_ALIGN': '19',
+   '_PC_SOCK_MAXBUF': '100',
+   '_PC_SYMLINK_MAX': '14',
+   '_PC_SYNC_IO': '11',
+   '_PC_TIMESTAMP_RESOLUTION': '20',
+   '_PC_VDISABLE': '8',
+   '_POINTER_INT': "<type 'long'>",
+   '_POSIX2_CHAR_TERM': '200112',
+   '_POSIX2_C_BIND': '200112',
+   '_POSIX2_C_DEV': '200112',
+   '_POSIX2_RE_DUP_MAX': '255',
+   '_POSIX2_SW_DEV': '200112',
+   '_POSIX2_UPE': '200112',
+   '_POSIX2_VERSION': '200112',
+   '_POSIX_ADVISORY_INFO': '200112',
+   '_POSIX_ASYNCHRONOUS_IO': '1',
+   '_POSIX_BARRIERS': '200112',
+   '_POSIX_CHOWN_RESTRICTED': '1',
+   '_POSIX_CPUTIME': '1',
+   '_POSIX_C_SOURCE': '2',
+   '_POSIX_DEVCTL_DIRECTION': '1',
+   '_POSIX_DEVICE_CONTROL': '1',
+   '_POSIX_FSYNC': '200112',
+   '_POSIX_INTERRUPT_CONTROL': '1',
+   '_POSIX_IPV6': '200112',
+   '_POSIX_JOB_CONTROL': '1',
+   '_POSIX_MAPPED_FILES': '200112',
+   '_POSIX_MEMLOCK': '1',
+   '_POSIX_MEMLOCK_RANGE': '200112',
+   '_POSIX_MEMORY_PROTECTION': '200112',
    '_POSIX_MESSAGE_PASSING': '200112',
-   'S_ISUID': '0004000',
-   'SIGLOST': '29',
+   '_POSIX_MONOTONIC_CLOCK': '200112',
+   '_POSIX_NO_TRUNC': '1',
+   '_POSIX_PRIORITIZED_IO': '1',
+   '_POSIX_PRIORITY_SCHEDULING': '200112',
+   '_POSIX_RAW_SOCKETS': '200112',
+   '_POSIX_READER_WRITER_LOCKS': '200112',
+   '_POSIX_REALTIME_SIGNALS': '200112',
+   '_POSIX_REGEXP': '1',
+   '_POSIX_SAVED_IDS': '1',
+   '_POSIX_SEMAPHORES': '200112',
+   '_POSIX_SHARED_MEMORY_OBJECTS': '200112',
+   '_POSIX_SHELL': '1',
+   '_POSIX_SPAWN': '1',
+   '_POSIX_SPIN_LOCKS': '200112',
+   '_POSIX_SPORADIC_SERVER': '1',
+   '_POSIX_SYNCHRONIZED_IO': '200112',
+   '_POSIX_THREADS': '200112',
+   '_POSIX_THREAD_ATTR_STACKADDR': '1',
+   '_POSIX_THREAD_ATTR_STACKSIZE': '200112',
+   '_POSIX_THREAD_CPUTIME': '1',
    '_POSIX_THREAD_PRIORITY_SCHEDULING': '200112',
-   'SDL_VIDEO_RENDER_OGL_ES2': '1',
-   '__FREEBSD__': '1',
-   '_SC_TZNAME_MAX': '20',
-   '_O_RAW': '65536',
-   '_CS_PATH': '0',
-   '_POSIX_BARRIERS': '200112',
-   'SDL_ALTIVEC_BLITTERS': '1',
-   'SEEK_SET': '0',
+   '_POSIX_THREAD_PRIO_INHERIT': '1',
+   '_POSIX_THREAD_PRIO_PROTECT': '1',
+   '_POSIX_THREAD_PROCESS_SHARED': '200112',
    '_POSIX_THREAD_SAFE_FUNCTIONS': '200112',
-   'S_IREAD': '0000400',
-   '_LONG_LONG_TYPE': "<type 'long'>",
-   '___int_least8_t_defined': '1',
-   'INT_MAX': '2147483647',
+   '_POSIX_THREAD_SPORADIC_SERVER': '1',
+   '_POSIX_TIMEOUTS': '1',
+   '_POSIX_TIMERS': '1',
+   '_POSIX_V6_ILP32_OFF32': '-1',
    '_POSIX_V6_ILP32_OFFBIG': '1',
-   '_SC_PHYS_PAGES': '11',
-   'HAVE_BCOPY': '1',
-   '_PC_MAX_CANON': '1',
-   'HAVE_STRICMP': '1',
-   '_CS_XBS5_LPBIG_OFFBIG_LDFLAGS': '14',
-   '_SC_THREAD_SAFE_FUNCTIONS': '49',
-   'SIGRTMAX': '31',
-   'S_IXGRP': '0000010',
-   'HAVE_GETENV': '1',
-   '_XBS5_LPBIG_OFFBIG': '-1',
-   '_PC_NAME_MAX': '3',
-   'O_EXCL': '2048',
-   '_SC_XOPEN_SHM': '103',
-   'S_IWGRP': '0000020',
-   '_SC_TRACE_USER_EVENT_MAX': '90',
-   'SDL_VIDEO_RENDER_D3D': '1',
-   'HAVE__STRNICMP': '1',
-   'M_SQRT1_2': '0.707106781187',
-   '_SC_AVPHYS_PAGES': '12',
-   '_SC_RAW_SOCKETS': '70',
-   'O_RDONLY': '0',
-   '_DATE_FMT': '84',
-   'HAVE_STRCASECMP': '1',
-   '__SOLARIS__': '1',
-   '_SC_RTSIG_MAX': '15',
-   '_POSIX_DEVICE_CONTROL': '1',
-   'CLOCK_ENABLED': '1',
-   '_NULL': '0',
-   '_SC_PRIORITIZED_IO': '28',
-   '_O_TEXT': '131072',
-   'SDL_VIDEO_DRIVER_X11_XVIDMODE': '1',
-   'SIGBUS': '10',
-   'CODESET': '0',
-   'CHAR_MAX': '127',
-   'SDL_POWER_NINTENDODS': '1',
-   'SIGSYS': '12',
-   '_PC_REC_INCR_XFER_SIZE': '16',
-   'S_IRUSR': '0000400',
-   '_PC_FILESIZEBITS': '12',
-   '_SC_XBS5_ILP32_OFF32': '92',
-   'HAVE_MATH_H': '1',
-   'HAVE_SQRT': '1',
-   'SIGURG': '16',
-   '_POSIX_THREAD_ATTR_STACKSIZE': '200112',
-   '_CS_POSIX_V7_LP64_OFF64_LIBS': '11',
-   '_CS_GNU_LIBPTHREAD_VERSION': '43',
-   'HAVE_M_PI': '1',
+   '_POSIX_V6_LP64_OFF64': '-1',
+   '_POSIX_V6_LPBIG_OFFBIG': '-1',
+   '_POSIX_VERSION': '200112',
+   '_RAND48_ADD': '11',
+   '_RAND48_MULT_0': '58989',
+   '_RAND48_MULT_1': '57068',
+   '_RAND48_MULT_2': '5',
+   '_RAND48_SEED_0': '13070',
+   '_RAND48_SEED_1': '43981',
+   '_RAND48_SEED_2': '4660',
+   '_READ_WRITE_RETURN_TYPE': "<type 'int'>",
    '_REENT_ASCTIME_SIZE': '26',
+   '_REENT_EMERGENCY_SIZE': '25',
+   '_REENT_SIGNAL_SIZE': '24',
+   '_SC_2_CHAR_TERM': '107',
+   '_SC_2_C_BIND': '108',
+   '_SC_2_C_DEV': '109',
+   '_SC_2_FORT_DEV': '110',
+   '_SC_2_FORT_RUN': '111',
+   '_SC_2_LOCALEDEF': '112',
+   '_SC_2_PBS': '113',
+   '_SC_2_PBS_ACCOUNTING': '114',
+   '_SC_2_PBS_CHECKPOINT': '115',
    '_SC_2_PBS_LOCATE': '116',
-   '_SC_V6_ILP32_OFF32': '92',
-   'SIGCHLD': '20',
-   'SHRT_MIN': '-32768',
-   '__HAIKU__': '1',
-   'PTHREAD_MUTEX_ERRORCHECK': '2',
-   '_PC_SYNC_IO': '11',
-   'SDL_VIDEO_OPENGL': '1',
-   'FP_NORMAL': '4',
+   '_SC_2_PBS_MESSAGE': '117',
+   '_SC_2_PBS_TRACK': '118',
+   '_SC_2_SW_DEV': '119',
    '_SC_2_UPE': '120',
-   'HAVE_POW': '1',
-   '_SC_SEM_NSEMS_MAX': '16',
-   '__ANDROID__': '1',
+   '_SC_2_VERSION': '121',
+   '_SC_ADVISORY_INFO': '54',
+   '_SC_AIO_LISTIO_MAX': '34',
+   '_SC_AIO_MAX': '35',
+   '_SC_AIO_PRIO_DELTA_MAX': '36',
+   '_SC_ARG_MAX': '0',
+   '_SC_ASYNCHRONOUS_IO': '21',
+   '_SC_ATEXIT_MAX': '55',
+   '_SC_AVPHYS_PAGES': '12',
+   '_SC_BARRIERS': '56',
+   '_SC_BC_BASE_MAX': '57',
+   '_SC_BC_DIM_MAX': '58',
+   '_SC_BC_SCALE_MAX': '59',
+   '_SC_BC_STRING_MAX': '60',
+   '_SC_CHILD_MAX': '1',
+   '_SC_CLK_TCK': '2',
+   '_SC_CLOCK_SELECTION': '61',
+   '_SC_COLL_WEIGHTS_MAX': '62',
+   '_SC_CPUTIME': '63',
+   '_SC_DELAYTIMER_MAX': '37',
+   '_SC_EXPR_NEST_MAX': '64',
+   '_SC_FSYNC': '22',
+   '_SC_GETGR_R_SIZE_MAX': '50',
+   '_SC_GETPW_R_SIZE_MAX': '51',
+   '_SC_HOST_NAME_MAX': '65',
    '_SC_IOV_MAX': '66',
-   'S_IRGRP': '0000040',
-   'YESSTR': '54',
-   'HAVE_ALLOCA_H': '1',
-   'S_IFCHR': '0020000',
-   '_POSIX_MEMLOCK': '1',
-   '_SC_TRACE': '83',
-   '_POSIX_INTERRUPT_CONTROL': '1',
-   '_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS': '6',
-   'PTHREAD_SCOPE_PROCESS': '0',
-   '__GNUC_VA_LIST': '1',
-   'HAVE_FABS': '1',
-   '_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS': '14',
-   'TLOSS': '5',
-   '_TIME_T_': "<type 'long'>",
-   'DOMAIN': '1',
-   'HAVE_REALLOC': '1',
-   'HAVE_STRLEN': '1',
-   '__IPHONEOS__': '1',
-   '_POINTER_INT': "<type 'long'>",
-   'O_NOCTTY': '32768',
-   'PTHREAD_PRIO_INHERIT': '1',
-   '_SC_THREAD_SPORADIC_SERVER': '81',
-   'O_ACCMODE': '3',
+   '_SC_IPV6': '67',
+   '_SC_JOB_CONTROL': '5',
    '_SC_LINE_MAX': '68',
-   'D_T_FMT': '1',
-   '_RAND48_SEED_1': '43981',
-   '_RAND48_SEED_0': '13070',
-   '_RAND48_SEED_2': '4660',
-   'HAVE_STRLCAT': '1',
-   'HAVE_SETJMP': '1',
-   'SDL_AUDIO_DRIVER_COREAUDIOIPHONE': '1',
-   'FOPEN': '-1',
-   'F_RGETLK': '10',
-   'F_DUPFD': '0',
-   '_S_IFCHR': '0020000',
-   'SDL_IPHONE_KEYBOARD': '1',
-   '_POSIX_IPV6': '200112',
-   '_XOPEN_VERSION': '600',
-   'HAVE_FLOOR': '1',
-   '_CS_XBS5_LP64_OFF64_LDFLAGS': '10',
-   '_FNOCTTY': '32768',
-   '_IFREG': '0100000',
-   'FP_SUBNORMAL': '3',
-   'SA_NOCLDSTOP': '1',
-   'HAVE_STDDEF_H': '1',
-   'NSIG': '32',
-   'HAVE__STRUPR': '1',
-   'SDL_THREAD_PTHREAD': '1',
-   'S_IWOTH': '0000002',
-   'SEEK_END': '2',
-   'SDL_ASSERT_LEVEL': '1',
-   'SI_ASYNCIO': '4',
-   'required_argument': '1',
-   '_FWRITE': '2',
-   'SCHED_RR': '2',
-   '_SC_2_FORT_DEV': '110',
-   'SA_NODEFER': '4',
-   '_POSIX2_CHAR_TERM': '200112',
-   'F_SETLK': '8',
-   'SIGQUIT': '3',
-   '_SC_ATEXIT_MAX': '55',
-   '_POSIX_MEMLOCK_RANGE': '200112',
+   '_SC_LOGIN_NAME_MAX': '52',
+   '_SC_MAPPED_FILES': '23',
+   '_SC_MEMLOCK': '24',
+   '_SC_MEMLOCK_RANGE': '25',
+   '_SC_MEMORY_PROTECTION': '26',
+   '_SC_MESSAGE_PASSING': '27',
+   '_SC_MONOTONIC_CLOCK': '69',
+   '_SC_MQ_OPEN_MAX': '13',
+   '_SC_MQ_PRIO_MAX': '14',
+   '_SC_NGROUPS_MAX': '3',
+   '_SC_NPROCESSORS_CONF': '9',
+   '_SC_NPROCESSORS_ONLN': '10',
+   '_SC_OPEN_MAX': '4',
+   '_SC_PAGESIZE': '8',
+   '_SC_PAGE_SIZE': '8',
+   '_SC_PHYS_PAGES': '11',
+   '_SC_PRIORITIZED_IO': '28',
+   '_SC_PRIORITY_SCHEDULING': '101',
+   '_SC_RAW_SOCKETS': '70',
+   '_SC_READER_WRITER_LOCKS': '71',
+   '_SC_REALTIME_SIGNALS': '29',
+   '_SC_REGEXP': '72',
+   '_SC_RE_DUP_MAX': '73',
+   '_SC_RTSIG_MAX': '15',
    '_SC_SAVED_IDS': '6',
-   'PTHREAD_INHERIT_SCHED': '1',
-   'SEEK_CUR': '1',
-   'S_IFLNK': '0120000',
-   '_S_IREAD': '0000400',
-   '_FOPEN': '-1',
-   'OVERFLOW': '3',
-   '_POSIX_SHELL': '1',
-   'FMARK': '16',
-   '_POSIX2_UPE': '200112',
-   'SDL_VIDEO_RENDER_OGL': '1',
-   '_SC_2_PBS_TRACK': '118',
-   '_POSIX_CPUTIME': '1',
+   '_SC_SEMAPHORES': '30',
+   '_SC_SEM_NSEMS_MAX': '16',
+   '_SC_SEM_VALUE_MAX': '17',
+   '_SC_SHARED_MEMORY_OBJECTS': '199',
+   '_SC_SHELL': '74',
+   '_SC_SIGQUEUE_MAX': '18',
+   '_SC_SPAWN': '75',
+   '_SC_SPIN_LOCKS': '76',
+   '_SC_SPORADIC_SERVER': '77',
+   '_SC_SS_REPL_MAX': '78',
+   '_SC_STREAM_MAX': '100',
+   '_SC_SYMLOOP_MAX': '79',
+   '_SC_SYNCHRONIZED_IO': '32',
+   '_SC_THREADS': '42',
+   '_SC_THREAD_ATTR_STACKADDR': '43',
+   '_SC_THREAD_ATTR_STACKSIZE': '44',
+   '_SC_THREAD_CPUTIME': '80',
+   '_SC_THREAD_DESTRUCTOR_ITERATIONS': '53',
+   '_SC_THREAD_KEYS_MAX': '38',
+   '_SC_THREAD_PRIORITY_SCHEDULING': '45',
+   '_SC_THREAD_PRIO_CEILING': '47',
+   '_SC_THREAD_PRIO_INHERIT': '46',
+   '_SC_THREAD_PRIO_PROTECT': '47',
    '_SC_THREAD_PROCESS_SHARED': '48',
-   '_SC_JOB_CONTROL': '5',
-   '_O_RDONLY': '0',
-   'FNBIO': '4096',
-   'O_CLOEXEC': '262144',
-   '_CS_XBS5_LP64_OFF64_LIBS': '11',
-   '_PC_TIMESTAMP_RESOLUTION': '20',
-   '_POSIX_READER_WRITER_LOCKS': '200112',
-   'ACCESSPERMS': '0000400',
-   '_POSIX_PRIORITIZED_IO': '1',
-   '_SC_IPV6': '67',
-   'SDL_VIDEO_OPENGL_WGL': '1',
-   '_CS_XBS5_ILP32_OFFBIG_LINTFLAGS': '8',
-   'HAVE__STRICMP': '1',
-   '_SC_ADVISORY_INFO': '54',
-   'SCHAR_MIN': '-128',
-   '_SC_XOPEN_REALTIME_THREADS': '102',
-   'SIGEV_SIGNAL': '2',
-   'HAVE_NANOSLEEP': '1',
-   'O_WRONLY': '1',
-   '_PC_SYMLINK_MAX': '14',
    '_SC_THREAD_ROBUST_PRIO_INHERIT': '122',
-   'X_OK': '1',
-   '_CS_XBS5_ILP32_OFF32_LDFLAGS': '2',
-   'SIGTERM': '15',
-   '_SC_COLL_WEIGHTS_MAX': '62',
-   '_CS_POSIX_V7_ILP32_OFF32_LDFLAGS': '2',
-   'NO_ARG': '0',
-   '_CS_POSIX_V7_LP64_OFF64_CFLAGS': '9',
-   'S_IWRITE': '0000200',
-   '_FEXLOCK': '256',
+   '_SC_THREAD_ROBUST_PRIO_PROTECT': '123',
+   '_SC_THREAD_SAFE_FUNCTIONS': '49',
+   '_SC_THREAD_SPORADIC_SERVER': '81',
+   '_SC_THREAD_STACK_MIN': '39',
+   '_SC_THREAD_THREADS_MAX': '40',
+   '_SC_TIMEOUTS': '82',
+   '_SC_TIMERS': '33',
+   '_SC_TIMER_MAX': '19',
+   '_SC_TRACE': '83',
+   '_SC_TRACE_EVENT_FILTER': '84',
+   '_SC_TRACE_EVENT_NAME_MAX': '85',
+   '_SC_TRACE_INHERIT': '86',
+   '_SC_TRACE_LOG': '87',
+   '_SC_TRACE_NAME_MAX': '88',
+   '_SC_TRACE_SYS_MAX': '89',
+   '_SC_TRACE_USER_EVENT_MAX': '90',
+   '_SC_TTY_NAME_MAX': '41',
+   '_SC_TYPED_MEMORY_OBJECTS': '91',
+   '_SC_TZNAME_MAX': '20',
+   '_SC_V6_ILP32_OFF32': '92',
+   '_SC_V6_ILP32_OFFBIG': '93',
+   '_SC_V6_LP64_OFF64': '94',
+   '_SC_V6_LPBIG_OFFBIG': '95',
+   '_SC_V7_ILP32_OFF32': '92',
+   '_SC_V7_ILP32_OFFBIG': '93',
+   '_SC_V7_LP64_OFF64': '94',
+   '_SC_V7_LPBIG_OFFBIG': '95',
+   '_SC_VERSION': '7',
+   '_SC_XBS5_ILP32_OFF32': '92',
+   '_SC_XBS5_ILP32_OFFBIG': '93',
+   '_SC_XBS5_LP64_OFF64': '94',
+   '_SC_XBS5_LPBIG_OFFBIG': '95',
+   '_SC_XOPEN_CRYPT': '96',
+   '_SC_XOPEN_ENH_I18N': '97',
+   '_SC_XOPEN_LEGACY': '98',
    '_SC_XOPEN_REALTIME': '99',
-   'SIGPWR': '19',
-   'SDL_AUDIO_DRIVER_WINMM': '1',
-   'HAVE_STRCHR': '1',
-   '_PC_PIPE_BUF': '5',
-   'SDL_HAPTIC_DINPUT': '1',
-   'SIGHUP': '1',
-   'F_GETOWN': '5',
-   'CLOCK_ALLOWED': '1',
-   'HAVE_MEMSET': '1',
-   'SIGUSR2': '31',
-   '_SC_2_PBS_ACCOUNTING': '114',
-   'F_TEST': '3',
-   'HAVE_VSNPRINTF': '1',
-   'ITIMER_REAL': '0',
-   'HAVE_SNPRINTF': '1',
-   'HAVE_SYS_TYPES_H': '1',
-   'HAVE_COPYSIGN': '1',
-   '_CLOCKS_PER_SEC_': '1000',
-   'SDL_HAPTIC_DUMMY': '1',
-   'SIGCONT': '19',
-   'NULL': '0',
-   'FSHLOCK': '128',
-   'STDOUT_FILENO': '1',
+   '_SC_XOPEN_REALTIME_THREADS': '102',
+   '_SC_XOPEN_SHM': '103',
+   '_SC_XOPEN_STREAMS': '104',
+   '_SC_XOPEN_UNIX': '105',
+   '_SC_XOPEN_UUCP': '124',
+   '_SC_XOPEN_VERSION': '106',
+   '_S_IEXEC': '0000100',
+   '_S_IFCHR': '0020000',
+   '_S_IFDIR': '0040000',
+   '_S_IFIFO': '0010000',
+   '_S_IFMT': '0170000',
+   '_S_IFREG': '0100000',
+   '_S_IREAD': '0000400',
+   '_S_IWRITE': '0000200',
+   '_TIME_T_': "<type 'long'>",
+   '_UNIX98_THREAD_MUTEX_ATTRIBUTES': '1',
+   '_XBS5_ILP32_OFF32': '-1',
+   '_XBS5_ILP32_OFFBIG': '1',
+   '_XBS5_LP64_OFF64': '-1',
+   '_XBS5_LPBIG_OFFBIG': '-1',
+   '_XOPEN_CRYPT': '1',
+   '_XOPEN_ENH_I18N': '1',
+   '_XOPEN_SHM': '1',
+   '_XOPEN_VERSION': '600',
    '__AIX__': '1',
-   'SDL_JOYSTICK_IOKIT': '1',
-   '_SC_THREAD_ATTR_STACKSIZE': '44',
-   'SIGIO': '23',
-   'HAVE_CEIL': '1',
-   'HAVE__STRLWR': '1',
-   'HAVE_SIGACTION': '1',
-   '_SC_CPUTIME': '63',
-   '_SC_2_VERSION': '121',
-   '_O_BINARY': '65536',
+   '__ANDROID__': '1',
+   '__BEOS__': '1',
+   '__BSDI__': '1',
+   '__BUFSIZ__': '16',
+   '__DREAMCAST__': '1',
+   '__FILENAME_MAX__': '255',
+   '__FREEBSD__': '1',
+   '__GNUC_VA_LIST': '1',
+   '__HAIKU__': '1',
+   '__HPUX__': '1',
+   '__INT_MAX__': '2147483647',
+   '__IPHONEOS__': '1',
+   '__IRIX__': '1',
+   '__LARGE64_FILES': '1',
+   '__LINUX__': '1',
+   '__long_double_t': "<type 'long'>",
+   '__LONG_MAX__': '2147483647',
+   '__MACOSX__': '1',
+   '__NETBSD__': '1',
+   '__NINTENDODS__': '1',
+   '__OPENBSD__': '1',
+   '__OS2__': '1',
+   '__OSF__': '1',
+   '__QNXNTO__': '1',
+   '__RAND_MAX': '2147483647',
+   '__RISCOS__': '1',
+   '__SIGFIRSTNOTRT': '1',
+   '__SIGLASTNOTRT': '31',
+   '__SOLARIS__': '1',
+   '__USE_XOPEN2K': '1',
+   '__WIN32__': '1',
+   '___int16_t_defined': '1',
+   '___int32_t_defined': '1',
+   '___int64_t_defined': '1',
+   '___int8_t_defined': '1',
    '___int_least16_t_defined': '1',
-   '_FTEXT': '131072',
-   '_POSIX2_SW_DEV': '200112',
-   '_LARGEFILE64_SOURCE': '1',
-   '_XOPEN_CRYPT': '1',
-   'FD_SETSIZE': '64',
-   'SDL_AUDIO_DRIVER_NDS': '1',
-   '_FMARK': '16',
-   '_SC_TYPED_MEMORY_OBJECTS': '91',
-   '_SC_ASYNCHRONOUS_IO': '21',
-   '_SC_2_CHAR_TERM': '107',
-   '_SC_AIO_LISTIO_MAX': '34',
-   'FCREAT': '512',
-   '_RAND48_ADD': '11',
-   'MAXPATHLEN': '1024',
-   '_SC_BC_SCALE_MAX': '59',
-   'SDL_IPHONE_MAX_GFORCE': '5.0',
-   'MATH_ERREXCEPT': '2',
-   'SDL_VIDEO_DRIVER_WINDOWS': '1',
-   '_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS': '13',
-   'M_SQRT3': '1.73205080757',
-   'M_SQRT2': '1.41421356237',
-   '_POSIX_THREADS': '200112',
-   'ABMON_12': '44',
-   'ABMON_11': '43',
-   'ABMON_10': '42',
-   'SI_QUEUE': '2',
-   'SDL_TIMER_UNIX': '1',
-   'AT_FDCWD': '-2',
-   'SIGTTOU': '22',
-   '_CS_POSIX_V7_LP64_OFF64_LDFLAGS': '10',
-   '_SC_TTY_NAME_MAX': '41',
-   'AF_INET': '2',
-   'AF_INET6': '6',
-   'PF_INET': '2',
-   'PF_INET6': '6',
-   'FIONREAD': '1',
-   'SOCK_STREAM': '200',
-   'SOCK_DGRAM': '20',
-   'IPPROTO_TCP': '1',
-   'IPPROTO_UDP': '2',
-   'EOF': '-1'
+   '___int_least32_t_defined': '1',
+   '___int_least8_t_defined': '1'
 };
 
diff --git a/system/include/bsd/sys/mman.h b/system/include/bsd/sys/mman.h
index 3c92c289..3713cacd 100644
--- a/system/include/bsd/sys/mman.h
+++ b/system/include/bsd/sys/mman.h
@@ -155,7 +155,7 @@ int	munlock __P((const void *, size_t));
 int	munmap __P((void *, size_t));
 #ifndef _POSIX_SOURCE
 int	madvise __P((void *, size_t, int));
-int	mincore __P((const void *, size_t, char *));
+int	mincore __P((const void *, size_t, unsigned char *));
 int	minherit __P((void *, size_t, int));
 #endif
 
diff --git a/system/include/libc/math.h b/system/include/libc/math.h
index 3bd0621c..e9af660f 100644
--- a/system/include/libc/math.h
+++ b/system/include/libc/math.h
@@ -202,10 +202,18 @@ extern int __signbitd (double x);
   #define isinf(y) (fpclassify(y) == FP_INFINITE)
 #endif
 
+#ifndef isinff
+  #define isinff isinf
+#endif
+
 #ifndef isnan
   #define isnan(y) (fpclassify(y) == FP_NAN)
 #endif
 
+#ifndef isnanf
+  #define isnanf isnan
+#endif
+
 #define isnormal(y) (fpclassify(y) == FP_NORMAL)
 #define signbit(__x) \
 	((sizeof(__x) == sizeof(float))  ?  __signbitf(__x) : \
diff --git a/system/include/sys/sendfile.h b/system/include/sys/sendfile.h
new file mode 100644
index 00000000..1f58f0dd
--- /dev/null
+++ b/system/include/sys/sendfile.h
@@ -0,0 +1,16 @@
+#ifndef _SYS_SENDFILE_H
+#define _SYS_SENDFILE_H
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/tests/cases/i32_mem.ll b/tests/cases/i24_mem_ta2.ll
index e50014ca..e50014ca 100644
--- a/tests/cases/i32_mem.ll
+++ b/tests/cases/i24_mem_ta2.ll
diff --git a/tests/cases/i32_mem.txt b/tests/cases/i24_mem_ta2.txt
index 683e58e2..683e58e2 100644
--- a/tests/cases/i32_mem.txt
+++ b/tests/cases/i24_mem_ta2.txt
diff --git a/tests/cases/structphiparam.ll b/tests/cases/structphiparam.ll
new file mode 100644
index 00000000..117bdf77
--- /dev/null
+++ b/tests/cases/structphiparam.ll
@@ -0,0 +1,36 @@
+; ModuleID = '/dev/shm/tmp/src.cpp.o'
+target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
+target triple = "i386-pc-linux-gnu"
+
+@.str = private unnamed_addr constant [15 x i8] c"hello, %d %d!\0A\00", align 1 ; [#uses=1 type=[15 x i8]*]
+@_dispatchTable = internal global i64 0
+
+define i32 @doit(i32 %x, { i32, i32 } %y) {
+  %y0 = extractvalue { i32, i32 } %y, 0
+  %y1 = extractvalue { i32, i32 } %y, 1
+  %call = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([15 x i8]* @.str, i32 0, i32 0), i32 %y0, i32 %y1) ; [#uses=0 type=i32] [debug line = 5:13]
+  ret i32 0
+}
+
+define i32 @main(i32 %argc) {
+entry:
+  %retval = alloca i32, align 4                   ; [#uses=1 type=i32*]
+  %myi64 = alloca i64, align 4
+  %comp = alloca { i32, i32 }, align 4            ; [#uses=1]
+  store i32 0, i32* %retval
+  %should = icmp ne i32 %argc, 1337
+  br i1 %should, label %cond.end, label %cond.null
+
+cond.null:
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi { i32, i32 } [ { i32 zext (i8 111 to i32), i32 6 }, %entry ], [ zeroinitializer, %cond.null ] ; [#uses=1]
+  store { i32, i32 } %cond, { i32, i32 }* %comp
+  %call = call i32 (i32, { i32, i32 })* @doit(i32 1, { i32, i32 } %cond) ;
+  ret i32 0                             ; [debug line = 6:13]
+}
+
+; [#uses=1]
+declare i32 @printf(i8*, ...)
+
diff --git a/tests/cases/structphiparam.txt b/tests/cases/structphiparam.txt
new file mode 100644
index 00000000..f5af49f1
--- /dev/null
+++ b/tests/cases/structphiparam.txt
@@ -0,0 +1 @@
+hello, 111 6!
diff --git a/tests/cube_explosion.c b/tests/cube_explosion.c
index 3f55b3c6..0c6eb674 100644
--- a/tests/cube_explosion.c
+++ b/tests/cube_explosion.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -230,8 +216,6 @@ int main(int argc, char *argv[])
     glDeleteTextures(1, &texture);
     assert(!glIsTexture(texture)); // but not anymore
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cube_explosion.png b/tests/cube_explosion.png
new file mode 100644
index 00000000..58a16f2b
--- /dev/null
+++ b/tests/cube_explosion.png
diff --git a/tests/cubegeom.c b/tests/cubegeom.c
index 787b8373..949a1f9a 100644
--- a/tests/cubegeom.c
+++ b/tests/cubegeom.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     int temp; // testing
@@ -308,9 +294,7 @@ int main(int argc, char *argv[])
     // END
 
     SDL_GL_SwapBuffers();
-
-    verify();
-   
+  
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom.png b/tests/cubegeom.png
new file mode 100644
index 00000000..1c6a7fd5
--- /dev/null
+++ b/tests/cubegeom.png
diff --git a/tests/cubegeom_color.png b/tests/cubegeom_color.png
new file mode 100644
index 00000000..a1d15438
--- /dev/null
+++ b/tests/cubegeom_color.png
diff --git a/tests/cubegeom_color2.c b/tests/cubegeom_color2.c
index 5294329d..76d71d00 100644
--- a/tests/cubegeom_color2.c
+++ b/tests/cubegeom_color2.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -287,8 +273,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_color2.png b/tests/cubegeom_color2.png
new file mode 100644
index 00000000..ee78eb63
--- /dev/null
+++ b/tests/cubegeom_color2.png
diff --git a/tests/cubegeom_fog.c b/tests/cubegeom_fog.c
index 9c04a55d..cae6ca2d 100644
--- a/tests/cubegeom_fog.c
+++ b/tests/cubegeom_fog.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -295,8 +281,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_fog.png b/tests/cubegeom_fog.png
new file mode 100644
index 00000000..c88e5a14
--- /dev/null
+++ b/tests/cubegeom_fog.png
diff --git a/tests/cubegeom_glew.c b/tests/cubegeom_glew.c
index 22ef5d74..a3d86a40 100644
--- a/tests/cubegeom_glew.c
+++ b/tests/cubegeom_glew.c
@@ -19,20 +19,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     int temp; // testing
@@ -297,8 +283,7 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
+  
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_mt.c b/tests/cubegeom_mt.c
index 464de7cc..b4ad28a7 100644
--- a/tests/cubegeom_mt.c
+++ b/tests/cubegeom_mt.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -288,8 +274,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_mt.png b/tests/cubegeom_mt.png
new file mode 100644
index 00000000..47649cdc
--- /dev/null
+++ b/tests/cubegeom_mt.png
diff --git a/tests/cubegeom_normal.c b/tests/cubegeom_normal.c
index d128fef2..02655edf 100644
--- a/tests/cubegeom_normal.c
+++ b/tests/cubegeom_normal.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -283,8 +269,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_normal.png b/tests/cubegeom_normal.png
new file mode 100644
index 00000000..7e3b35d1
--- /dev/null
+++ b/tests/cubegeom_normal.png
diff --git a/tests/cubegeom_normal_dap.c b/tests/cubegeom_normal_dap.c
index f811c586..752911a8 100644
--- a/tests/cubegeom_normal_dap.c
+++ b/tests/cubegeom_normal_dap.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -279,8 +265,7 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
+  
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_normal_dap_far.c b/tests/cubegeom_normal_dap_far.c
index f954b3c7..35a068d9 100644
--- a/tests/cubegeom_normal_dap_far.c
+++ b/tests/cubegeom_normal_dap_far.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -277,8 +263,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_normal_dap_far_glda.c b/tests/cubegeom_normal_dap_far_glda.c
index a4b4975b..849245b8 100644
--- a/tests/cubegeom_normal_dap_far_glda.c
+++ b/tests/cubegeom_normal_dap_far_glda.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -268,8 +254,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_normal_dap_far_glda.png b/tests/cubegeom_normal_dap_far_glda.png
new file mode 100644
index 00000000..815efeb9
--- /dev/null
+++ b/tests/cubegeom_normal_dap_far_glda.png
diff --git a/tests/cubegeom_normal_dap_far_glda_quad.c b/tests/cubegeom_normal_dap_far_glda_quad.c
index aa6383b8..93c157a4 100644
--- a/tests/cubegeom_normal_dap_far_glda_quad.c
+++ b/tests/cubegeom_normal_dap_far_glda_quad.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -268,8 +254,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_normal_dap_far_glda_quad.png b/tests/cubegeom_normal_dap_far_glda_quad.png
new file mode 100644
index 00000000..8683b0ed
--- /dev/null
+++ b/tests/cubegeom_normal_dap_far_glda_quad.png
diff --git a/tests/cubegeom_normal_dap_far_range.c b/tests/cubegeom_normal_dap_far_range.c
index eb54c22a..17691ce9 100644
--- a/tests/cubegeom_normal_dap_far_range.c
+++ b/tests/cubegeom_normal_dap_far_range.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -277,8 +263,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_normal_dap_far_range.png b/tests/cubegeom_normal_dap_far_range.png
new file mode 100644
index 00000000..7e3b35d1
--- /dev/null
+++ b/tests/cubegeom_normal_dap_far_range.png
diff --git a/tests/cubegeom_pre.c b/tests/cubegeom_pre.c
index 8001a2b8..fb1a5e02 100644
--- a/tests/cubegeom_pre.c
+++ b/tests/cubegeom_pre.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -295,8 +281,7 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-    
+   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_pre.png b/tests/cubegeom_pre.png
new file mode 100644
index 00000000..0a8c95cb
--- /dev/null
+++ b/tests/cubegeom_pre.png
diff --git a/tests/cubegeom_pre2.c b/tests/cubegeom_pre2.c
index ae8dcf9f..51961bf7 100644
--- a/tests/cubegeom_pre2.c
+++ b/tests/cubegeom_pre2.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -334,8 +320,6 @@ int main(int argc, char *argv[])
     // END
 
     SDL_GL_SwapBuffers();
-
-    verify();
   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
diff --git a/tests/cubegeom_pre2.png b/tests/cubegeom_pre2.png
new file mode 100644
index 00000000..0a8c95cb
--- /dev/null
+++ b/tests/cubegeom_pre2.png
diff --git a/tests/cubegeom_pre2_vao.c b/tests/cubegeom_pre2_vao.c
index 98bedd54..cba262ff 100644
--- a/tests/cubegeom_pre2_vao.c
+++ b/tests/cubegeom_pre2_vao.c
@@ -33,20 +33,6 @@ PFNGLGENVERTEXARRAYSPROC glGenVertexArrays_ = NULL;
 PFNGLBINDVERTEXARRAYPROC glBindVertexArray_ = NULL;
 PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays_ = NULL;
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -367,8 +353,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-  
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_pre2_vao2.c b/tests/cubegeom_pre2_vao2.c
index e3ab4d62..3784006c 100644
--- a/tests/cubegeom_pre2_vao2.c
+++ b/tests/cubegeom_pre2_vao2.c
@@ -33,20 +33,6 @@ PFNGLGENVERTEXARRAYSPROC glGenVertexArrays_ = NULL;
 PFNGLBINDVERTEXARRAYPROC glBindVertexArray_ = NULL;
 PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays_ = NULL;
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -368,8 +354,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-  
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_pre2_vao2.png b/tests/cubegeom_pre2_vao2.png
new file mode 100644
index 00000000..1e18bcd9
--- /dev/null
+++ b/tests/cubegeom_pre2_vao2.png
diff --git a/tests/cubegeom_pre3.c b/tests/cubegeom_pre3.c
index a1f811b6..4ba2a779 100644
--- a/tests/cubegeom_pre3.c
+++ b/tests/cubegeom_pre3.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -335,8 +321,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_pre_vao.c b/tests/cubegeom_pre_vao.c
index f1d35fb5..cae68cfc 100644
--- a/tests/cubegeom_pre_vao.c
+++ b/tests/cubegeom_pre_vao.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -321,8 +307,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-    
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_pre_vao.png b/tests/cubegeom_pre_vao.png
new file mode 100644
index 00000000..0a8c95cb
--- /dev/null
+++ b/tests/cubegeom_pre_vao.png
diff --git a/tests/cubegeom_texturematrix.c b/tests/cubegeom_texturematrix.c
index 229bf2a8..99a4469e 100644
--- a/tests/cubegeom_texturematrix.c
+++ b/tests/cubegeom_texturematrix.c
@@ -29,20 +29,6 @@ REDISTRIBUTION OF THIS SOFTWARE.
 #include <string.h>
 #include <assert.h>
 
-void verify() {
-  int width = 640, height = 480;
-  unsigned char *data = (unsigned char*)malloc(width*height*4);
-  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
-  int sum = 0;
-  for (int x = 0; x < width*height*4; x++) {
-    if (x % 4 != 3) sum += x * data[x];
-  }
-#if EMSCRIPTEN
-  int result = sum;
-  REPORT_RESULT();
-#endif
-}
-
 int main(int argc, char *argv[])
 {
     SDL_Surface *screen;
@@ -300,8 +286,6 @@ int main(int argc, char *argv[])
 
     SDL_GL_SwapBuffers();
 
-    verify();
-   
 #if !EMSCRIPTEN
     SDL_Delay(1500);
 #endif
diff --git a/tests/cubegeom_texturematrix.png b/tests/cubegeom_texturematrix.png
new file mode 100644
index 00000000..9144b9e4
--- /dev/null
+++ b/tests/cubegeom_texturematrix.png
diff --git a/tests/dirent/test_readdir.c b/tests/dirent/test_readdir.c
index 9f7b12e8..12f97b73 100644
--- a/tests/dirent/test_readdir.c
+++ b/tests/dirent/test_readdir.c
@@ -2,6 +2,7 @@
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -129,4 +130,4 @@ int main() {
   setup();
   test();
   return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/tests/fcntl-open/src.c b/tests/fcntl-open/src.c
index bd52dd3f..fc5d5c76 100644
--- a/tests/fcntl-open/src.c
+++ b/tests/fcntl-open/src.c
@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -91,4 +92,4 @@ int main() {
   setup();
   test();
   return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/tests/filesystem/output.txt b/tests/filesystem/output.txt
index dd58133c..06e0a0bb 100644
--- a/tests/filesystem/output.txt
+++ b/tests/filesystem/output.txt
@@ -7,7 +7,7 @@
   object.contents: ["123","456","deviceA","localLink","rootLink","relativeLink"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 /
   isRoot: true
@@ -15,10 +15,10 @@
   error: 0
   path: /
   name: /
-  object.contents: ["forbidden","abc","def"]
+  object.contents: ["tmp","dev","forbidden","abc","def"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 .
   isRoot: false
@@ -29,7 +29,7 @@
   object.contents: ["123","456","deviceA","localLink","rootLink","relativeLink"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 ..
   isRoot: true
@@ -37,10 +37,10 @@
   error: 0
   path: /
   name: /
-  object.contents: ["forbidden","abc","def"]
+  object.contents: ["tmp","dev","forbidden","abc","def"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 ../..
   isRoot: true
@@ -48,10 +48,10 @@
   error: 0
   path: /
   name: /
-  object.contents: ["forbidden","abc","def"]
+  object.contents: ["tmp","dev","forbidden","abc","def"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 /abc
   isRoot: false
@@ -62,7 +62,7 @@
   object.contents: ["123","456","deviceA","localLink","rootLink","relativeLink"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 /abc/123
   isRoot: false
@@ -114,10 +114,10 @@
   error: 0
   path: /
   name: /
-  object.contents: ["forbidden","abc","def"]
+  object.contents: ["tmp","dev","forbidden","abc","def"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 /abc/relativeLink
   isRoot: false
@@ -128,7 +128,7 @@
   object.contents: ["789","deviceB"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 /abc/relativeLink/deviceB
   isRoot: false
@@ -150,7 +150,7 @@
   object.contents: null
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 /abc/rootLink/abc/noexist
   isRoot: false
@@ -172,7 +172,7 @@
   object.contents: ["test"]
   parentExists: true
   parentPath: /
-  parentObject.contents: ["forbidden","abc","def"]
+  parentObject.contents: ["tmp","dev","forbidden","abc","def"]
 
 /forbidden/test
   isRoot: false
diff --git a/tests/openal_buffers.c b/tests/openal_buffers.c
new file mode 100644
index 00000000..6f51a685
--- /dev/null
+++ b/tests/openal_buffers.c
@@ -0,0 +1,187 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#ifdef EMSCRIPTEN
+#include <emscripten.h>
+#include <AL/al.h>
+#include <AL/alc.h>
+#else
+#include "../system/include/AL/al.h"
+#include "../system/include/AL/alc.h"
+#endif
+
+#define NUM_BUFFERS 4
+#define BUFFER_SIZE 1470*10
+
+ALCdevice* device = NULL;
+ALCcontext* context = NULL;
+
+// Audio source state.
+unsigned char* data = NULL;
+unsigned int size = 0;
+unsigned int offset = 0;
+unsigned int channels = 0;
+unsigned int frequency = 0;
+unsigned int bits = 0;
+ALenum format = 0;
+ALuint source = 0;
+
+void iter(void *arg) {
+  ALuint buffer = 0;
+  ALint buffersProcessed = 0;
+  ALint buffersWereQueued = 0;
+  ALint buffersQueued = 0;
+  ALint state;
+
+  alGetSourcei(source, AL_BUFFERS_PROCESSED, &buffersProcessed);
+
+  while (offset < size && buffersProcessed--) {
+    // unqueue the old buffer and validate the queue length
+    alGetSourcei(source, AL_BUFFERS_QUEUED, &buffersWereQueued);
+    alSourceUnqueueBuffers(source, 1, &buffer);
+
+    assert(alGetError() == AL_NO_ERROR);
+    int len = size - offset;
+    if (len > BUFFER_SIZE) {
+      len = BUFFER_SIZE;
+    }
+
+    alGetSourcei(source, AL_BUFFERS_QUEUED, &buffersQueued);
+    assert(buffersQueued == buffersWereQueued - 1);
+
+    // queue the new buffer and validate the queue length
+    buffersWereQueued = buffersQueued;
+    alBufferData(buffer, format, &data[offset], len, frequency);
+
+    alSourceQueueBuffers(source, 1, &buffer);
+    assert(alGetError() == AL_NO_ERROR);
+
+    alGetSourcei(source, AL_BUFFERS_QUEUED, &buffersQueued);
+    assert(buffersQueued == buffersWereQueued + 1);
+
+    // make sure it's still playing
+    alGetSourcei(source, AL_SOURCE_STATE, &state);
+    assert(state == AL_PLAYING);
+
+    offset += len;
+  }
+
+  // Exit once we've processed the entire clip.
+  if (offset >= size) {
+#ifdef EMSCRIPTEN
+    int result = 0;
+    REPORT_RESULT();
+#endif
+    exit(0);
+  }
+}
+
+int main(int argc, char* argv[]) {
+  //
+  // Setup the AL context.
+  //
+  device = alcOpenDevice(NULL);
+  context = alcCreateContext(device, NULL);
+  alcMakeContextCurrent(context);
+
+  //
+  // Read in the audio sample.
+  //
+#ifdef EMSCRIPTEN
+  FILE* fp = fopen("the_entertainer.wav", "rb");
+#else
+  FILE* fp = fopen("sounds/the_entertainer.wav", "rb");
+#endif
+  fseek(fp, 0, SEEK_END);
+  size = ftell(fp);
+  fseek(fp, 0, SEEK_SET);
+
+  data = (unsigned char*)malloc(size);
+  fread(data, size, 1, fp);
+  fclose(fp);
+
+  offset = 12; // ignore the RIFF header
+  offset += 8; // ignore the fmt header
+  offset += 2; // ignore the format type
+
+  channels = data[offset + 1] << 8;
+  channels |= data[offset];
+  offset += 2;
+  printf("Channels: %u\n", channels);
+
+  frequency = data[offset + 3] << 24;
+  frequency |= data[offset + 2] << 16;
+  frequency |= data[offset + 1] << 8;
+  frequency |= data[offset];
+  offset += 4;
+  printf("Frequency: %u\n", frequency);
+
+  offset += 6; // ignore block size and bps
+
+  bits = data[offset + 1] << 8;
+  bits |= data[offset];
+  offset += 2;
+  printf("Bits: %u\n", bits);
+
+  format = 0;
+  if (bits == 8) {
+    if (channels == 1) {
+      format = AL_FORMAT_MONO8;
+    } else if (channels == 2) {
+      format = AL_FORMAT_STEREO8;
+    }
+  } else if (bits == 16) {
+    if (channels == 1) {
+      format = AL_FORMAT_MONO16;
+    } else if (channels == 2) {
+      format = AL_FORMAT_STEREO16;
+    }
+  }
+  offset += 8; // ignore the data chunk
+
+  //
+  // Seed the buffers with some initial data.
+  //
+  ALuint buffers[NUM_BUFFERS];
+  alGenBuffers(NUM_BUFFERS, buffers);
+  alGenSources(1, &source);
+
+  ALint numBuffers = 0;
+  while (numBuffers < NUM_BUFFERS && offset < size) {
+    int len = size - offset;
+    if (len > BUFFER_SIZE) {
+      len = BUFFER_SIZE;
+    }
+
+    alBufferData(buffers[numBuffers], format, &data[offset], len, frequency);
+    alSourceQueueBuffers(source, 1, &buffers[numBuffers]);
+    assert(alGetError() == AL_NO_ERROR);
+
+    offset += len;
+    numBuffers++;
+  }
+
+  //
+  // Start playing the source.
+  //
+  alSourcePlay(source);
+
+  ALint state;
+  alGetSourcei(source, AL_SOURCE_STATE, &state);
+  assert(state == AL_PLAYING);
+
+  alGetSourcei(source, AL_BUFFERS_QUEUED, &numBuffers);
+  assert(numBuffers == NUM_BUFFERS);
+
+  //
+  // Cycle and refill the buffers until we're done.
+  //
+#if EMSCRIPTEN
+  emscripten_set_main_loop(iter, 0, 0);
+#else
+  while (1) {
+    iter(NULL);
+    usleep(16);
+  }
+#endif
+}
diff --git a/tests/qsort/benchmark.cpp b/tests/qsort/benchmark.cpp
new file mode 100644
index 00000000..950ca437
--- /dev/null
+++ b/tests/qsort/benchmark.cpp
@@ -0,0 +1,43 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+typedef unsigned int uint32;
+
+int cmp_uint(const void *i1, const void *i2) {
+  if (*static_cast<const uint32*>(i1) >
+      *static_cast<const uint32*>(i2))
+    return 1;
+
+  if (*static_cast<const uint32*>(i1) <
+      *static_cast<const uint32*>(i2))
+    return -1;
+
+  return 0;
+}
+
+int main() {
+  clock_t start = clock();
+  const size_t TIMES = 10000;
+  for (size_t i = 0; i < TIMES; i++) {
+    const size_t num = 100;
+    uint32 rnd[num] = { \
+      407, 236, 765, 529,  24,  13, 577, 900, 242, 245, \
+      782, 972, 514, 100, 596, 470, 680,  65, 370, 788, \
+       44, 330, 579, 314, 914, 399, 100, 945, 992, 412, \
+      308, 102, 895, 529, 216, 422, 851, 778,  28, 804, \
+      325, 975, 961, 623, 922, 667, 141, 755, 416, 575, \
+      712, 503, 174, 675,  14, 647, 544, 881, 858, 621, \
+       26, 283, 460, 252, 146,  16, 571, 570,  14, 143, \
+      674, 985, 477, 386, 932, 490, 611, 127, 702, 619, \
+      104, 892,  58, 635, 663, 424, 714, 740, 229, 538, \
+      167, 181, 193, 193, 657, 778, 217, 573, 764, 745};
+
+    qsort(rnd, num, sizeof(uint32), cmp_uint);
+  }
+  clock_t end = clock();
+
+  float diff = (((float)end - (float)start) / CLOCKS_PER_SEC ) * 1000;
+  printf("cost %fms\n", diff);
+}
+
diff --git a/tests/runner.py b/tests/runner.py
index 1948ab59..84e8b69e 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -5025,6 +5025,36 @@ The current type of b is: 9
       '''
       self.do_run(src, 'time: ') # compilation check, mainly
 
+    def test_gmtime(self):
+      src = r'''
+        #include <stdio.h>
+        #include <stdlib.h>
+        #include <time.h>
+        #include <assert.h>
+
+        int main(void)
+        {
+            time_t t=time(NULL);
+            struct tm *ptm=gmtime(&t);
+            struct tm tmCurrent=*ptm;
+            int hour=tmCurrent.tm_hour;
+
+            t-=hour*3600; // back to midnight
+            int yday = -1;
+            for(hour=0;hour<24;hour++)
+            {
+                ptm=gmtime(&t);
+                // tm_yday must be constant all day...
+                printf("yday: %d, hour: %d\n", ptm->tm_yday, hour);
+                if (yday == -1) yday = ptm->tm_yday;
+                else assert(yday == ptm->tm_yday);
+                t+=3600; // add one hour
+            }
+            printf("ok!\n");
+            return(0);
+        }
+      '''
+      self.do_run(src, '''ok!''')
 
     def test_strptime_tm(self):
       src=r'''
@@ -5313,7 +5343,7 @@ The current type of b is: 9
           return 0;
         }
         '''
-      self.do_run(src, 'fault on write to 0' if not Settings.ASM_JS else 'Assertion: 0')
+      self.do_run(src, 'fault on write to 0' if not Settings.ASM_JS else 'abort()')
 
     def test_trickystring(self):
       src = r'''
@@ -9060,6 +9090,7 @@ def process(filename):
 
       src = r'''
         #include <stdio.h>
+        #include <stdlib.h>
 
         extern "C" {
           int get_int() { return 5; }
@@ -9082,42 +9113,44 @@ def process(filename):
           if (argc == 15) print_string(argv[0]);
           if (argc == 16) pointer((int*)argv[0]);
           if (argc % 17 == 12) return multi(argc, float(argc)/2, argc+1, argv[0]);
-          return 0;
+          // return 0;
+          exit(0);
         }
       '''
 
       post = '''
 def process(filename):
   src = \'\'\'
-    var Module = {
-      'postRun': function() {
-        Module.print('*');
-        var ret;
-        ret = Module['ccall']('get_int', 'number'); Module.print([typeof ret, ret]);
-        ret = ccall('get_float', 'number'); Module.print([typeof ret, ret.toFixed(2)]);
-        ret = ccall('get_string', 'string'); Module.print([typeof ret, ret]);
-        ret = ccall('print_int', null, ['number'], [12]); Module.print(typeof ret);
-        ret = ccall('print_float', null, ['number'], [14.56]); Module.print(typeof ret);
-        ret = ccall('print_string', null, ['string'], ["cheez"]); Module.print(typeof ret);
-        ret = ccall('print_string', null, ['array'], [[97, 114, 114, 45, 97, 121, 0]]); Module.print(typeof ret);
-        ret = ccall('multi', 'number', ['number', 'number', 'number', 'string'], [2, 1.4, 3, 'more']); Module.print([typeof ret, ret]);
-        var p = ccall('malloc', 'pointer', ['number'], [4]);
-        setValue(p, 650, 'i32');
-        ret = ccall('pointer', 'pointer', ['pointer'], [p]); Module.print([typeof ret, getValue(ret, 'i32')]);
-        Module.print('*');
-        // part 2: cwrap
-        var multi = Module['cwrap']('multi', 'number', ['number', 'number', 'number', 'string']);
-        Module.print(multi(2, 1.4, 3, 'atr'));
-        Module.print(multi(8, 5.4, 4, 'bret'));
-        Module.print('*');
-        // part 3: avoid stack explosion
-        for (var i = 0; i < TOTAL_STACK/60; i++) {
-          ccall('multi', 'number', ['number', 'number', 'number', 'string'], [0, 0, 0, '123456789012345678901234567890123456789012345678901234567890']);
-        }
-        Module.print('stack is ok.');
+    var Module = { noInitialRun: true };
+    \'\'\' + open(filename, 'r').read() + \'\'\'
+    Module.addOnExit(function () {
+      Module.print('*');
+      var ret;
+      ret = Module['ccall']('get_int', 'number'); Module.print([typeof ret, ret]);
+      ret = ccall('get_float', 'number'); Module.print([typeof ret, ret.toFixed(2)]);
+      ret = ccall('get_string', 'string'); Module.print([typeof ret, ret]);
+      ret = ccall('print_int', null, ['number'], [12]); Module.print(typeof ret);
+      ret = ccall('print_float', null, ['number'], [14.56]); Module.print(typeof ret);
+      ret = ccall('print_string', null, ['string'], ["cheez"]); Module.print(typeof ret);
+      ret = ccall('print_string', null, ['array'], [[97, 114, 114, 45, 97, 121, 0]]); Module.print(typeof ret);
+      ret = ccall('multi', 'number', ['number', 'number', 'number', 'string'], [2, 1.4, 3, 'more']); Module.print([typeof ret, ret]);
+      var p = ccall('malloc', 'pointer', ['number'], [4]);
+      setValue(p, 650, 'i32');
+      ret = ccall('pointer', 'pointer', ['pointer'], [p]); Module.print([typeof ret, getValue(ret, 'i32')]);
+      Module.print('*');
+      // part 2: cwrap
+      var multi = Module['cwrap']('multi', 'number', ['number', 'number', 'number', 'string']);
+      Module.print(multi(2, 1.4, 3, 'atr'));
+      Module.print(multi(8, 5.4, 4, 'bret'));
+      Module.print('*');
+      // part 3: avoid stack explosion
+      for (var i = 0; i < TOTAL_STACK/60; i++) {
+        ccall('multi', 'number', ['number', 'number', 'number', 'string'], [0, 0, 0, '123456789012345678901234567890123456789012345678901234567890']);
       }
-    };
-  \'\'\' + open(filename, 'r').read()
+      Module.print('stack is ok.');
+    });
+    Module.callMain();
+  \'\'\'
   open(filename, 'w').write(src)
 '''
 
@@ -9329,6 +9362,26 @@ def process(filename):
       '''
       self.do_run(src, 'abs(-10): 10\nabs(-11): 11');
 
+    def test_embind_2(self):
+      if self.emcc_args is None: return self.skip('requires emcc')
+      Building.COMPILER_TEST_OPTS += ['--bind', '--post-js', 'post.js']
+      open('post.js', 'w').write('''
+        Module.print('lerp ' + Module.lerp(1, 2, 0.66) + '.');
+      ''')
+      src = r'''
+        #include <stdio.h>
+        #include <SDL/SDL.h>
+        #include <emscripten/bind.h>
+        using namespace emscripten;
+        float lerp(float a, float b, float t) {
+            return (1 - t) * a + t * b;
+        }
+        EMSCRIPTEN_BINDINGS(my_module) {
+            function("lerp", &lerp);
+        }
+      '''
+      self.do_run(src, 'lerp 1.66');
+
     def test_scriptaclass(self):
         if self.emcc_args is None: return self.skip('requires emcc')
 
@@ -10680,6 +10733,27 @@ f.close()
             os.chdir(path_from_root('tests')) # Move away from the directory we are about to remove.
             shutil.rmtree(tempdirname)
 
+    def test_nostdincxx(self):
+      try:
+        old = os.environ.get('EMCC_LLVM_TARGET') or ''
+        for compiler in [EMCC, EMXX]:
+          for target in ['i386-pc-linux-gnu', 'le32-unknown-nacl']:
+            print compiler, target
+            os.environ['EMCC_LLVM_TARGET'] = target
+            out, err = Popen([PYTHON, EMCC, path_from_root('tests', 'hello_world.cpp'), '-v'], stdout=PIPE, stderr=PIPE).communicate()
+            out2, err2 = Popen([PYTHON, EMCC, path_from_root('tests', 'hello_world.cpp'), '-v', '-nostdinc++'], stdout=PIPE, stderr=PIPE).communicate()
+            assert out == out2
+            def focus(e):
+              assert 'search starts here:' in e, e
+              assert e.count('End of search list.') == 1, e
+              return e[e.index('search starts here:'):e.index('End of search list.')+20]
+            err = focus(err)
+            err2 = focus(err2)
+            assert err == err2, err + '\n\n\n\n' + err2
+      finally:
+        if old:
+          os.environ['EMCC_LLVM_TARGET'] = old
+
     def test_failure_error_code(self):
       for compiler in [EMCC, EMXX]:
         # Test that if one file is missing from the build, then emcc shouldn't succeed, and shouldn't try to produce an output file.
@@ -11034,6 +11108,23 @@ f.close()
         std::string side() { return "and hello from side"; }
       ''', ['hello from main and hello from side\n'])
 
+      # followup to iostream test: a second linking
+      print 'second linking of a linking output'
+      open('moar.cpp', 'w').write(r'''
+        #include <iostream>
+        struct Moar {
+          Moar() { std::cout << "moar!" << std::endl; }
+        };
+        Moar m;
+      ''')
+      Popen([PYTHON, EMCC, 'moar.cpp', '-o', 'moar.js', '-s', 'SIDE_MODULE=1', '-O2']).communicate()
+      Popen([PYTHON, EMLINK, 'together.js', 'moar.js', 'triple.js'], stdout=PIPE).communicate()
+      assert os.path.exists('triple.js')
+      for engine in JS_ENGINES:
+        out = run_js('triple.js', engine=engine, stderr=PIPE, full_output=True)
+        self.assertContained('moar!\nhello from main and hello from side\n', out)
+        if engine == SPIDERMONKEY_ENGINE: self.validate_asmjs(out)
+
       # zlib compression library. tests function pointers in initializers and many other things
       test('zlib', '', open(path_from_root('tests', 'zlib', 'example.c'), 'r').read(), 
                        self.get_library('zlib', os.path.join('libz.a'), make_args=['libz.a']),
@@ -11246,6 +11337,29 @@ int main(int argc, char const *argv[])
       # node's stdin support is broken
       self.assertContained('abc', Popen(listify(SPIDERMONKEY_ENGINE) + ['a.out.js'], stdin=open('in.txt'), stdout=PIPE, stderr=PIPE).communicate()[0])
 
+    def test_ungetc_fscanf(self):
+      open('main.cpp', 'w').write(r'''
+        #include <stdio.h>
+        int main(int argc, char const *argv[])
+        {
+            char str[4] = {0};
+            FILE* f = fopen("my_test.input", "r");
+            if (f == NULL) {
+                printf("cannot open file\n");
+                return -1;
+            }
+            ungetc('x', f);
+            ungetc('y', f);
+            ungetc('z', f);
+            fscanf(f, "%3s", str);
+            printf("%s\n", str);
+            return 0;
+        }
+      ''')
+      open('my_test.input', 'w').write('abc')
+      Building.emcc('main.cpp', ['--embed-file', 'my_test.input'], output_filename='a.out.js')
+      self.assertContained('zyx', Popen(listify(JS_ENGINES[0]) + ['a.out.js'], stdout=PIPE, stderr=PIPE).communicate()[0])
+
     def test_abspaths(self):
       # Includes with absolute paths are generally dangerous, things like -I/usr/.. will get to system local headers, not our portable ones.
 
@@ -11951,7 +12065,9 @@ int main(int argc, char const *argv[])
         ([], True), # without --bind, we fail
         (['--bind'], False),
         (['--bind', '-O1'], False),
-        (['--bind', '-O2'], False)
+        (['--bind', '-O2'], False),
+        (['--bind', '-O1', '-s', 'ASM_JS=0'], False),
+        (['--bind', '-O2', '-s', 'ASM_JS=0'], False)
       ]:
         print args, fail
         self.clear()
@@ -12070,6 +12186,36 @@ seeked= file.
       self.assertNotContained('emcc: warning: treating -s as linker option', output[1])
       assert os.path.exists('conftest')
 
+    def test_file_packager(self):
+      try:
+        os.mkdir('subdir')
+      except:
+        pass
+      open('data1.txt', 'w').write('data1')
+      os.chdir('subdir')
+      open('data2.txt', 'w').write('data2')
+      # relative path to below the current dir is invalid
+      out, err = Popen([PYTHON, FILE_PACKAGER, 'test.data', '--preload', '../data1.txt'], stdout=PIPE, stderr=PIPE).communicate()
+      assert len(out) == 0
+      assert 'below the current directory' in err
+      # relative path that ends up under us is cool
+      out, err = Popen([PYTHON, FILE_PACKAGER, 'test.data', '--preload', '../subdir/data2.txt'], stdout=PIPE, stderr=PIPE).communicate()
+      assert len(out) > 0
+      assert 'below the current directory' not in err
+      # direct path leads to the same code being generated - relative path does not make us do anything different
+      out2, err2 = Popen([PYTHON, FILE_PACKAGER, 'test.data', '--preload', 'data2.txt'], stdout=PIPE, stderr=PIPE).communicate()
+      assert len(out2) > 0
+      assert 'below the current directory' not in err2
+      def clean(txt):
+        return filter(lambda line: 'PACKAGE_UUID' not in line, txt.split('\n'))
+      out = clean(out)
+      out2 = clean(out2)
+      assert out == out2
+      # sanity check that we do generate different code for different inputs
+      out3, err3 = Popen([PYTHON, FILE_PACKAGER, 'test.data', '--preload', 'data2.txt', 'data2.txt@waka.txt'], stdout=PIPE, stderr=PIPE).communicate()
+      out3 = clean(out3)
+      assert out != out3
+
     def test_crunch(self):
       # crunch should not be run if a .crn exists that is more recent than the .dds
       shutil.copyfile(path_from_root('tests', 'ship.dds'), 'ship.dds')
@@ -12131,6 +12277,7 @@ elif 'browser' in str(sys.argv):
       'browser.test_sdl_audio_mix',
       'browser.test_sdl_audio_quickload',
       'browser.test_openal_playback',
+      'browser.test_openal_buffers',
       'browser.test_freealut'
     ]
 
@@ -12196,7 +12343,7 @@ elif 'browser' in str(sys.argv):
     @classmethod
     def tearDownClass(cls):
       if not hasattr(browser, 'harness_server'): return
-
+      
       browser.harness_server.terminate()
       delattr(browser, 'harness_server')
       print '[Browser harness server terminated]'
@@ -12270,6 +12417,14 @@ elif 'browser' in str(sys.argv):
             var actualUrl = Module.canvas.toDataURL();
             var actualImage = new Image();
             actualImage.onload = function() {
+              /*
+              document.body.appendChild(img); // for comparisons
+              var div = document.createElement('div');
+              div.innerHTML = '^=expected, v=actual';
+              document.body.appendChild(div);
+              document.body.appendChild(actualImage); // to grab it for creating the test reference
+              */
+
               var actualCanvas = document.createElement('canvas');
               actualCanvas.width = actualImage.width;
               actualCanvas.height = actualImage.height;
@@ -12570,7 +12725,7 @@ Press any key to continue.'''
       open(absolute_src_path2, 'w').write('''load me right before running the code please''')
       
       def make_main(path):
-        print path
+        print 'make main at', path
         open(os.path.join(self.get_dir(), 'main.cpp'), 'w').write(self.with_report_result(r'''
           #include <stdio.h>
           #include <string.h>
@@ -12608,14 +12763,14 @@ Press any key to continue.'''
       
       for test in test_cases:
         (srcpath, dstpath) = test
+        print 'Testing', srcpath, dstpath
         make_main(dstpath)
-        print srcpath
         Popen([PYTHON, EMCC, os.path.join(self.get_dir(), 'main.cpp'), '--preload-file', srcpath, '-o', 'page.html']).communicate()
         self.run_browser('page.html', 'You should see |load me right before|.', '/report_result?1')
 
       # By absolute path
 
-      make_main(absolute_src_path)
+      make_main('somefile.txt') # absolute becomes relative
       Popen([PYTHON, EMCC, os.path.join(self.get_dir(), 'main.cpp'), '--preload-file', absolute_src_path, '-o', 'page.html']).communicate()
       self.run_browser('page.html', 'You should see |load me right before|.', '/report_result?1')
 
@@ -12675,7 +12830,7 @@ Press any key to continue.'''
         
       # Should still work with -o subdir/..
 
-      make_main(absolute_src_path)
+      make_main('somefile.txt') # absolute becomes relative
       try:
         os.mkdir(os.path.join(self.get_dir(), 'dirrey'))
       except:
@@ -12868,6 +13023,16 @@ Press any key to continue.'''
       shutil.copyfile(path_from_root('tests', 'screenshot.jpg'), os.path.join(self.get_dir(), 'screenshot.not'))
       self.btest('sdl_image_prepare_data.c', reference='screenshot.jpg', args=['--preload-file', 'screenshot.not'])
 
+    def test_sdl_stb_image(self):
+      # load an image file, get pixel data.
+      shutil.copyfile(path_from_root('tests', 'screenshot.jpg'), os.path.join(self.get_dir(), 'screenshot.not'))
+      self.btest('sdl_stb_image.c', reference='screenshot.jpg', args=['-s', 'STB_IMAGE=1', '--preload-file', 'screenshot.not'])
+
+    def test_sdl_stb_image_data(self):
+      # load an image file, get pixel data.
+      shutil.copyfile(path_from_root('tests', 'screenshot.jpg'), os.path.join(self.get_dir(), 'screenshot.not'))
+      self.btest('sdl_stb_image_data.c', reference='screenshot.jpg', args=['-s', 'STB_IMAGE=1', '--preload-file', 'screenshot.not'])
+
     def test_sdl_canvas(self):
       open(os.path.join(self.get_dir(), 'sdl_canvas.c'), 'w').write(self.with_report_result(open(path_from_root('tests', 'sdl_canvas.c')).read()))
 
@@ -13080,20 +13245,20 @@ Press any key to continue.'''
 
     def test_sdl_ogl(self):
       shutil.copyfile(path_from_root('tests', 'screenshot.png'), os.path.join(self.get_dir(), 'screenshot.png'))
-      self.btest('sdl_ogl.c', reference='screenshot-gray-purple.png',
+      self.btest('sdl_ogl.c', reference='screenshot-gray-purple.png', reference_slack=1,
         args=['-O2', '--minify', '0', '--preload-file', 'screenshot.png'],
         message='You should see an image with gray at the top.')
 
     def test_sdl_ogl_defaultmatrixmode(self):
       shutil.copyfile(path_from_root('tests', 'screenshot.png'), os.path.join(self.get_dir(), 'screenshot.png'))
-      self.btest('sdl_ogl_defaultMatrixMode.c', reference='screenshot-gray-purple.png',
+      self.btest('sdl_ogl_defaultMatrixMode.c', reference='screenshot-gray-purple.png', reference_slack=1,
         args=['--minify', '0', '--preload-file', 'screenshot.png'],
         message='You should see an image with gray at the top.')
 
     def test_sdl_ogl_p(self):
       # Immediate mode with pointers
       shutil.copyfile(path_from_root('tests', 'screenshot.png'), os.path.join(self.get_dir(), 'screenshot.png'))
-      self.btest('sdl_ogl_p.c', reference='screenshot-gray.png',
+      self.btest('sdl_ogl_p.c', reference='screenshot-gray.png', reference_slack=1,
         args=['--preload-file', 'screenshot.png'],
         message='You should see an image with gray at the top.')
 
@@ -13123,7 +13288,7 @@ Press any key to continue.'''
 
     def test_sdl_fog_linear(self):
       shutil.copyfile(path_from_root('tests', 'screenshot.png'), os.path.join(self.get_dir(), 'screenshot.png'))
-      self.btest('sdl_fog_linear.c', reference='screenshot-fog-linear.png',
+      self.btest('sdl_fog_linear.c', reference='screenshot-fog-linear.png', reference_slack=1,
         args=['--preload-file', 'screenshot.png'],
         message='You should see an image with fog.')
 
@@ -13134,6 +13299,10 @@ Press any key to continue.'''
       Popen([PYTHON, EMCC, '-O2', os.path.join(self.get_dir(), 'openal_playback.cpp'), '--preload-file', 'audio.wav', '-o', 'page.html']).communicate()
       self.run_browser('page.html', '', '/report_result?1')
 
+    def test_openal_buffers(self):
+      shutil.copyfile(path_from_root('tests', 'sounds', 'the_entertainer.wav'), os.path.join(self.get_dir(), 'the_entertainer.wav'))
+      self.btest('openal_buffers.c', '0', args=['--preload-file', 'the_entertainer.wav'],)
+
     def test_glfw(self):
       open(os.path.join(self.get_dir(), 'glfw.c'), 'w').write(self.with_report_result(open(path_from_root('tests', 'glfw.c')).read()))
 
@@ -13422,12 +13591,12 @@ Press any key to continue.'''
     def test_gl_ps(self):
       # pointers and a shader
       shutil.copyfile(path_from_root('tests', 'screenshot.png'), os.path.join(self.get_dir(), 'screenshot.png'))
-      self.btest('gl_ps.c', reference='gl_ps.png', args=['--preload-file', 'screenshot.png'])
+      self.btest('gl_ps.c', reference='gl_ps.png', args=['--preload-file', 'screenshot.png'], reference_slack=1)
 
     def test_gl_ps_packed(self):
       # packed data that needs to be strided
       shutil.copyfile(path_from_root('tests', 'screenshot.png'), os.path.join(self.get_dir(), 'screenshot.png'))
-      self.btest('gl_ps_packed.c', reference='gl_ps.png', args=['--preload-file', 'screenshot.png'])
+      self.btest('gl_ps_packed.c', reference='gl_ps.png', args=['--preload-file', 'screenshot.png'], reference_slack=1)
 
     def test_gl_ps_strides(self):
       shutil.copyfile(path_from_root('tests', 'screenshot.png'), os.path.join(self.get_dir(), 'screenshot.png'))
@@ -13443,64 +13612,64 @@ Press any key to continue.'''
       self.btest('gl_matrix_identity.c', expected=['-1882984448', '460451840'])
 
     def test_cubegeom_pre(self):
-      self.btest('cubegeom_pre.c', expected=['-1472804742', '-1626058463', '-2046234971'])
+      self.btest('cubegeom_pre.c', reference='cubegeom_pre.png')
 
     def test_cubegeom_pre2(self):
-      self.btest('cubegeom_pre2.c', expected=['-1472804742', '-1626058463', '-2046234971'], args=['-s', 'GL_DEBUG=1']) # some coverage for GL_DEBUG not breaking the build
+      self.btest('cubegeom_pre2.c', reference='cubegeom_pre2.png', args=['-s', 'GL_DEBUG=1']) # some coverage for GL_DEBUG not breaking the build
 
     def test_cubegeom_pre3(self):
-      self.btest('cubegeom_pre3.c', expected=['-1472804742', '-1626058463', '-2046234971'])
+      self.btest('cubegeom_pre3.c', reference='cubegeom_pre2.png')
 
     def test_cubegeom(self):
-      self.btest('cubegeom.c', args=['-O2', '-g'], expected=['188641320', '1522377227', '-1054007155', '-1111866053'])
+      self.btest('cubegeom.c', args=['-O2', '-g'], reference='cubegeom.png')
 
     def test_cubegeom_glew(self):
-      self.btest('cubegeom_glew.c', args=['-O2', '--closure', '1'], expected=['188641320', '1522377227', '-1054007155', '-1111866053'])
+      self.btest('cubegeom_glew.c', args=['-O2', '--closure', '1'], reference='cubegeom.png')
 
     def test_cubegeom_color(self):
-      self.btest('cubegeom_color.c', expected=['588472350', '-687660609', '-818120875'])
+      self.btest('cubegeom_color.c', reference='cubegeom_color.png')
 
     def test_cubegeom_normal(self):
-      self.btest('cubegeom_normal.c', expected=['752917084', '-251570256', '-291655550'])
+      self.btest('cubegeom_normal.c', reference='cubegeom_normal.png')
 
     def test_cubegeom_normal_dap(self): # draw is given a direct pointer to clientside memory, no element array buffer
-      self.btest('cubegeom_normal_dap.c', expected=['752917084', '-251570256', '-291655550'])
+      self.btest('cubegeom_normal_dap.c', reference='cubegeom_normal.png')
 
     def test_cubegeom_normal_dap_far(self): # indices do nto start from 0
-      self.btest('cubegeom_normal_dap_far.c', expected=['752917084', '-251570256', '-291655550'])
+      self.btest('cubegeom_normal_dap_far.c', reference='cubegeom_normal.png')
 
     def test_cubegeom_normal_dap_far_range(self): # glDrawRangeElements
-      self.btest('cubegeom_normal_dap_far_range.c', expected=['752917084', '-251570256', '-291655550'])
+      self.btest('cubegeom_normal_dap_far_range.c', reference='cubegeom_normal.png')
 
     def test_cubegeom_normal_dap_far_glda(self): # use glDrawArrays
-      self.btest('cubegeom_normal_dap_far_glda.c', expected=['-218745386', '-263951846', '-375182658'])
+      self.btest('cubegeom_normal_dap_far_glda.c', reference='cubegeom_normal_dap_far_glda.png')
 
     def test_cubegeom_normal_dap_far_glda_quad(self): # with quad
-      self.btest('cubegeom_normal_dap_far_glda_quad.c', expected=['1757386625', '-677777235', '-690699597'])
+      self.btest('cubegeom_normal_dap_far_glda_quad.c', reference='cubegeom_normal_dap_far_glda_quad.png')
 
     def test_cubegeom_mt(self):
-      self.btest('cubegeom_mt.c', expected=['-457159152', '910983047', '870576921']) # multitexture
+      self.btest('cubegeom_mt.c', reference='cubegeom_mt.png') # multitexture
 
     def test_cubegeom_color2(self):
-      self.btest('cubegeom_color2.c', expected=['1121999515', '-391668088', '-522128354'])
+      self.btest('cubegeom_color2.c', reference='cubegeom_color2.png')
 
     def test_cubegeom_texturematrix(self):
-      self.btest('cubegeom_texturematrix.c', expected=['1297500583', '-791216738', '-783804685'])
+      self.btest('cubegeom_texturematrix.c', reference='cubegeom_texturematrix.png')
 
     def test_cubegeom_fog(self):
-      self.btest('cubegeom_fog.c', expected=['1617140399', '-898782526', '-946179526'])
+      self.btest('cubegeom_fog.c', reference='cubegeom_fog.png')
 
     def test_cubegeom_pre_vao(self):
-      self.btest('cubegeom_pre_vao.c', expected=['-1472804742', '-1626058463', '-2046234971'])
+      self.btest('cubegeom_pre_vao.c', reference='cubegeom_pre_vao.png')
 
     def test_cubegeom_pre2_vao(self):
-      self.btest('cubegeom_pre2_vao.c', expected=['-1472804742', '-1626058463', '-2046234971'])
+      self.btest('cubegeom_pre2_vao.c', reference='cubegeom_pre_vao.png')
 
     def test_cubegeom_pre2_vao2(self):
-      self.btest('cubegeom_pre2_vao2.c', expected=['-790445118'])
+      self.btest('cubegeom_pre2_vao2.c', reference='cubegeom_pre2_vao2.png')
 
     def test_cube_explosion(self):
-      self.btest('cube_explosion.c', expected=['667220544', '-1543354600', '-1485258415'])
+      self.btest('cube_explosion.c', reference='cube_explosion.png')
 
     def test_sdl_canvas_blank(self):
       self.btest('sdl_canvas_blank.c', reference='sdl_canvas_blank.png')
@@ -14766,12 +14935,31 @@ fi
         finally:
           del os.environ['EMCC_DEBUG']
 
+      restore()
+
+      def ensure_cache():
+        self.do([EMCC, '-O2', path_from_root('tests', 'hello_world.c')])
+
       # Manual cache clearing
+      ensure_cache()
       assert os.path.exists(EMCC_CACHE)
       output = self.do([EMCC, '--clear-cache'])
       assert ERASING_MESSAGE in output
       assert not os.path.exists(EMCC_CACHE)
 
+      # Changing LLVM_ROOT, even without altering .emscripten, clears the cache
+      ensure_cache()
+      old = os.environ.get('LLVM')
+      try:
+        os.environ['LLVM'] = 'waka'
+        assert os.path.exists(EMCC_CACHE)
+        output = self.do([EMCC])
+        assert ERASING_MESSAGE in output
+        assert not os.path.exists(EMCC_CACHE)
+      finally:
+        if old: os.environ['LLVM'] = old
+        else: del os.environ['LLVM']
+
       try_delete(CANONICAL_TEMP_DIR)
 
     def test_relooper(self):
diff --git a/tests/sdl_stb_image.c b/tests/sdl_stb_image.c
new file mode 100644
index 00000000..6d39cb8e
--- /dev/null
+++ b/tests/sdl_stb_image.c
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <SDL/SDL.h>
+#include <SDL/SDL_image.h>
+#include <assert.h>
+#include <emscripten.h>
+
+SDL_Surface* screen;
+
+int testImage(const char* fileName) {
+  SDL_Surface *image = IMG_Load(fileName);
+  if (!image)
+  {
+     printf("IMG_Load: %s\n", IMG_GetError());
+     return 0;
+  }
+  assert(image->format->BitsPerPixel == 32);
+  assert(image->format->BytesPerPixel == 4);
+  assert(image->pitch == 4*image->w);
+  int result = image->w;
+
+  SDL_BlitSurface (image, NULL, screen, NULL);
+  SDL_FreeSurface (image);
+
+  return result;
+}
+
+void ready() {
+  printf("ready!\n");
+
+  testImage("screenshot.jpg"); // relative path
+
+  SDL_Flip(screen);
+}
+
+int main() {
+  SDL_Init(SDL_INIT_VIDEO);
+  screen = SDL_SetVideoMode(600, 450, 32, SDL_SWSURFACE);
+
+  printf("rename..\n");
+
+  rename("screenshot.not", "screenshot.jpg");
+
+  printf("decode..\n");
+
+  ready();
+
+  return 0;
+}
+
diff --git a/tests/sdl_stb_image_data.c b/tests/sdl_stb_image_data.c
new file mode 100644
index 00000000..d702b4cc
--- /dev/null
+++ b/tests/sdl_stb_image_data.c
@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <SDL/SDL.h>
+#include <SDL/SDL_image.h>
+#include <assert.h>
+#include <emscripten.h>
+
+#define SIZE 203164
+SDL_Surface* screen;
+char *buffer;
+
+int testImage() {
+  SDL_Surface *image = IMG_Load_RW(SDL_RWFromMem(buffer, SIZE), 1);
+  if (!image)
+  {
+     printf("IMG_Load: %s\n", IMG_GetError());
+     return 0;
+  }
+
+  printf("load succeeded\n");
+
+  assert(image->format->BitsPerPixel == 32);
+  assert(image->format->BytesPerPixel == 4);
+  assert(image->pitch == 4*image->w);
+  int result = image->w;
+
+  SDL_BlitSurface (image, NULL, screen, NULL);
+  SDL_FreeSurface (image);
+
+  return result;
+}
+
+void ready() {
+  testImage();
+
+  SDL_Flip(screen);
+}
+
+int main() {
+  SDL_Init(SDL_INIT_VIDEO);
+  screen = SDL_SetVideoMode(600, 450, 32, SDL_SWSURFACE);
+
+  printf("prepare..\n");
+
+  FILE *f = fopen("screenshot.not", "rb");
+  buffer = malloc(SIZE);
+  fread(buffer, SIZE, 1, f);
+  fclose(f);
+
+  ready();
+
+  return 0;
+}
+
diff --git a/tests/sounds/the_entertainer.wav b/tests/sounds/the_entertainer.wav
new file mode 100644
index 00000000..6402e312
--- /dev/null
+++ b/tests/sounds/the_entertainer.wav
diff --git a/tests/stat/test_chmod.c b/tests/stat/test_chmod.c
index 94e6c12b..bf0e2cbe 100644
--- a/tests/stat/test_chmod.c
+++ b/tests/stat/test_chmod.c
@@ -2,6 +2,7 @@
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -150,4 +151,4 @@ int main() {
   setup();
   test();
   return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/tests/stat/test_mknod.c b/tests/stat/test_mknod.c
index 4cff57d9..2b8f650d 100644
--- a/tests/stat/test_mknod.c
+++ b/tests/stat/test_mknod.c
@@ -2,6 +2,7 @@
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -93,4 +94,4 @@ int main() {
   setup();
   test();
   return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/tests/stat/test_stat.c b/tests/stat/test_stat.c
index 14e88370..2c2bf53d 100644
--- a/tests/stat/test_stat.c
+++ b/tests/stat/test_stat.c
@@ -2,6 +2,7 @@
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -164,4 +165,4 @@ int main() {
   setup();
   test();
   return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/tests/stdio/test_fgetc_ungetc.c b/tests/stdio/test_fgetc_ungetc.c
index c69a3d1a..0eea4007 100644
--- a/tests/stdio/test_fgetc_ungetc.c
+++ b/tests/stdio/test_fgetc_ungetc.c
@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -47,7 +48,9 @@ void test() {
   ungetc('a', file);
   err = fgetc(file);
   assert(err == (int)'a');
-  fread(buffer, sizeof(char), sizeof(buffer), file);
+  int r = fread(buffer, sizeof(char), sizeof(buffer), file);
+  assert(r == 3);
+  buffer[3] = 0;
   assert(!strcmp(buffer, "bcd"));
 
   // rewind and fseek should reset anything that's been
@@ -84,4 +87,4 @@ int main() {
   setup();
   test();
   return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/tests/unistd/unlink.c b/tests/unistd/unlink.c
index 87252da2..f0a8f4dd 100644
--- a/tests/unistd/unlink.c
+++ b/tests/unistd/unlink.c
@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -135,4 +136,4 @@ int main() {
   setup();
   test();
   return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/tests/utime/test_utime.c b/tests/utime/test_utime.c
index 1793f4a5..59e3e98a 100644
--- a/tests/utime/test_utime.c
+++ b/tests/utime/test_utime.c
@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <errno.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -50,4 +51,4 @@ int main() {
   setup();
   test();
   return EXIT_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/third_party/stb_image.c b/third_party/stb_image.c
new file mode 100644
index 00000000..098b91ae
--- /dev/null
+++ b/third_party/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

+*/

diff --git a/tools/asm_module.py b/tools/asm_module.py
new file mode 100644
index 00000000..e54cfc21
--- /dev/null
+++ b/tools/asm_module.py
@@ -0,0 +1,271 @@
+
+import sys, re
+
+import shared, js_optimizer
+
+
+class AsmModule():
+  def __init__(self, filename):
+    self.filename = filename
+    self.js = open(filename).read()
+
+    self.start_asm = self.js.find(js_optimizer.start_asm_marker)
+    self.start_funcs = self.js.find(js_optimizer.start_funcs_marker)
+    self.end_funcs = self.js.rfind(js_optimizer.end_funcs_marker)
+    self.end_asm = self.js.rfind(js_optimizer.end_asm_marker)
+
+    # pre and asm
+    self.pre_js = self.js[:self.start_asm]
+    self.asm_js = self.js[self.start_asm:self.end_asm]
+
+    # heap initializer
+    self.staticbump = int(re.search(shared.JS.memory_staticbump_pattern, self.pre_js).group(1))
+    if self.staticbump:
+      self.mem_init_js = re.search(shared.JS.memory_initializer_pattern, self.pre_js).group(0)
+
+    # global initializers
+    global_inits = re.search(shared.JS.global_initializers_pattern, self.pre_js)
+    if global_inits:
+      self.global_inits_js = global_inits.group(0)
+      self.global_inits = map(lambda init: init.split('{')[2][1:].split('(')[0], global_inits.groups(0)[0].split(','))
+    else:
+      self.global_inits_js = ''
+      self.global_inits = []
+
+    # imports (and global variables)
+    first_var = self.js.find('var ', self.js.find('var ', self.start_asm)+4)
+    self.pre_imports_js = self.js[self.start_asm:first_var]
+    self.imports_js = self.js[first_var:self.start_funcs]
+    self.imports = {}
+    for imp in js_optimizer.import_sig.finditer(self.imports_js):
+      key, value = imp.group(0).split('var ')[1][:-1].split('=', 1)
+      self.imports[key.strip()] = value.strip()
+    #print >> sys.stderr, 'imports', self.imports
+
+    # funcs
+    self.funcs_js = self.js[self.start_funcs:self.end_funcs]
+    self.funcs = set([m.group(2) for m in js_optimizer.func_sig.finditer(self.funcs_js)])
+    #print 'funcs', self.funcs
+
+    # tables and exports
+    post_js = self.js[self.end_funcs:self.end_asm]
+    ret = post_js.find('return')
+    self.tables_js = post_js[:ret]
+    self.exports_js = post_js[ret:]
+    self.tables = self.parse_tables(self.tables_js)
+    self.exports = set([export.strip() for export in self.exports_js[self.exports_js.find('{')+1:self.exports_js.find('}')].split(',')])
+
+    # post
+    self.post_js = self.js[self.end_asm:]
+    self.sendings = {}
+    for sending in [sending.strip() for sending in self.post_js[self.post_js.find('}, { ')+5:self.post_js.find(' }, buffer);')].split(',')]:
+      colon = sending.find(':')
+      self.sendings[sending[:colon].replace('"', '')] = sending[colon+1:].strip()
+    self.module_defs = set(re.findall('var [\w\d_$]+ = Module\["[\w\d_$]+"\] = asm\["[\w\d_$]+"\];\n', self.post_js))
+
+  def relocate_into(self, main):
+    # heap initializer
+    if self.staticbump > 0:
+      new_mem_init = self.mem_init_js[:self.mem_init_js.rfind(', ')] + ', Runtime.GLOBAL_BASE+%d)' % main.staticbump
+      main.pre_js = re.sub(shared.JS.memory_staticbump_pattern, 'STATICTOP = STATIC_BASE + %d;\n' % (main.staticbump + self.staticbump) + new_mem_init, main.pre_js, count=1)
+
+    # Find function name replacements TODO: do not rename duplicate names with duplicate contents, just merge them
+    replacements = {}
+    for func in self.funcs:
+      rep = func
+      while rep in main.funcs:
+        rep += '_'
+        replacements[func] = rep
+    #print >> sys.stderr, 'replacements:', replacements
+
+    # sendings: add invokes for new tables
+    all_sendings = main.sendings
+    added_sending = False
+    for table in self.tables:
+      if table not in main.tables:
+        sig = table[table.rfind('_')+1:]
+        all_sendings['invoke_%s' % sig] = shared.JS.make_invoke(sig, named=False)
+        added_sending = True
+
+    # imports
+    all_imports = main.imports
+    for key, value in self.imports.iteritems():
+      if key in self.funcs or key in main.funcs: continue # external function in one module, implemented in the other
+      value_concrete = '.' not in value # env.key means it is an import, an external value, and not a concrete one
+      main_value = main.imports.get(key)
+      main_value_concrete = main_value and '.' not in main_value
+      if value_concrete and main_value_concrete: continue # standard global var
+      if not main_value or value_concrete:
+        if '+' in value:
+          # relocate
+          value = value.replace('(', '').replace(')', '').replace('| 0', '').replace('|0', '').replace(' ', '')
+          left, right = value.split('+')
+          assert left == 'H_BASE'
+          value = str(main.staticbump + int(right))
+        all_imports[key] = value
+      if (value_concrete or main_value_concrete) and key in all_sendings:
+        del all_sendings[key] # import of external value no longer needed
+    main.imports_js = '\n'.join(['var %s = %s;' % (key, value) for key, value in all_imports.iteritems()]) + '\n'
+
+    # check for undefined references to global variables
+    def check_import(key, value):
+      if value.startswith('+') or value.endswith('|0'): # ignore functions
+        if key not in all_sendings:
+          print >> sys.stderr, 'warning: external variable %s is still not defined after linking' % key
+          all_sendings[key] = '0'
+    for key, value in all_imports.iteritems(): check_import(key, value)
+
+    if added_sending:
+      sendings_js = ', '.join(['%s: %s' % (key, value) for key, value in all_sendings.iteritems()])
+      sendings_start = main.post_js.find('}, { ')+5
+      sendings_end = main.post_js.find(' }, buffer);')
+      main.post_js = main.post_js[:sendings_start] + sendings_js + main.post_js[sendings_end:]
+
+    # tables
+    f_bases = {}
+    f_sizes = {}
+    for table, data in self.tables.iteritems():
+      main.tables[table] = self.merge_tables(table, main.tables.get(table), data, replacements, f_bases, f_sizes)
+    main.combine_tables()
+    #print >> sys.stderr, 'f bases', f_bases
+
+    # relocate
+    temp = shared.Building.js_optimizer(self.filename, ['asm', 'relocate', 'last'], extra_info={
+      'replacements': replacements,
+      'fBases': f_bases,
+      'hBase': main.staticbump
+    })
+    #print >> sys.stderr, 'relocated side into', temp
+    relocated_funcs = AsmModule(temp)
+    shared.try_delete(temp)
+    main.extra_funcs_js = relocated_funcs.funcs_js.replace(js_optimizer.start_funcs_marker, '\n')
+
+    # update function table uses
+    ft_marker = 'FUNCTION_TABLE_'
+
+    def update_fts(what):
+      updates = []
+      i = 1 # avoid seeing marker in recursion
+      while 1:
+        i = what.find(ft_marker, i)
+        if i < 0: break;
+        start = i
+        end = what.find('[', start)
+        table = what[i:end]
+        if table not in f_sizes:
+          # table was not modified
+          i += len(ft_marker)
+          continue
+        nesting = 1
+        while nesting > 0:
+          next = what.find(']', end+1)
+          nesting -= 1
+          nesting += what.count('[', end+1, next)
+          end = next
+        assert end > 0
+        mask = what.rfind('&', start, end)
+        assert mask > 0 and end - mask <= 13
+        fixed = update_fts(what[start:mask+1] + str(f_sizes[table]-1) + ']')
+        updates.append((start, end, fixed))
+        i = end # additional function table uses were done by recursion
+      # apply updates
+      if len(updates) == 0: return what
+      parts = []
+      so_far = 0
+      for i in range(len(updates)):
+        start, end, fixed = updates[i]
+        parts.append(what[so_far:start])
+        parts.append(fixed)
+        so_far = end+1
+      parts.append(what[so_far:])
+      return ''.join(parts)
+
+    main.funcs_js = update_fts(main.funcs_js)
+    main.extra_funcs_js = update_fts(main.extra_funcs_js)
+
+    # global initializers
+    if self.global_inits:
+      my_global_inits = map(lambda init: replacements[init] if init in replacements else init, self.global_inits)
+      all_global_inits = map(lambda init: '{ func: function() { %s() } }' % init, main.global_inits + my_global_inits)
+      all_global_inits_js = '/* global initializers */ __ATINIT__.push(' + ','.join(all_global_inits) + ');'
+      if main.global_inits:
+        target = main.global_inits_js
+      else:
+        target = '// === Body ===\n'
+        all_global_inits_js = target + all_global_inits_js
+      main.pre_js = main.pre_js.replace(target, all_global_inits_js)
+
+    # exports
+    def rep_exp(export):
+      key, value = export.split(':')
+      if key in replacements:
+        repped = replacements[key]
+        return repped + ': ' + repped
+      return export
+    my_exports = map(rep_exp, self.exports)
+    exports = main.exports.union(my_exports)
+    main.exports_js = 'return {' + ','.join(list(exports)) + '};\n})\n'
+
+    # post
+    def rep_def(deff):
+      key = deff.split(' ')[1]
+      if key in replacements:
+        rep = replacements[key]
+        return 'var %s = Module["%s"] = asm["%s"];\n' % (rep, rep, rep)
+      return deff
+    my_module_defs = map(rep_def, self.module_defs)
+    new_module_defs = set(my_module_defs).difference(main.module_defs)
+    if len(new_module_defs) > 0:
+      position = main.post_js.find('Runtime.') # Runtime is the start of the hardcoded ones
+      main.post_js = main.post_js[:position] + ''.join(list(new_module_defs)) + '\n' + main.post_js[position:]
+
+  def write(self, out):
+    f = open(out, 'w')
+    f.write(self.pre_js)
+    f.write(self.pre_imports_js)
+    f.write(self.imports_js)
+    f.write(self.funcs_js)
+    f.write(self.extra_funcs_js)
+    f.write(self.tables_js)
+    f.write(self.exports_js)
+    f.write(self.post_js)
+    f.close()
+
+  # Utilities
+
+  def parse_tables(self, js):
+    tables = {}
+    parts = js.split(';')
+    for part in parts:
+      if '=' not in part: continue
+      part = part.split('var ')[1]
+      name, data = part.split('=')
+      tables[name.strip()] = data.strip()
+    return tables
+
+  def merge_tables(self, table, main, side, replacements, f_bases, f_sizes):
+    sig = table.split('_')[-1]
+    side = side[1:-1].split(',')
+    side = map(lambda f: replacements[f] if f in replacements else f, side)
+    if not main:
+      f_bases[sig] = 0
+      f_sizes[table] = len(side)
+      return '[' + ','.join(side) + ']'
+    main = main[1:-1].split(',')
+    # TODO: handle non-aliasing case too
+    assert len(main) % 2 == 0
+    f_bases[sig] = len(main)
+    ret = main + side
+    size = 2
+    while size < len(ret): size *= 2
+    aborter = ret[1] # we can assume odd indexes have an aborting function with the right signature
+    ret = ret + [aborter]*(size - len(ret))
+    assert len(ret) == size
+    f_sizes[table] = size
+    return '[' + ','.join(ret) + ']'
+
+  def combine_tables(self):
+    self.tables_js = '// EMSCRIPTEN_END_FUNCS\n'
+    for table, data in self.tables.iteritems():
+      self.tables_js += 'var %s = %s;\n' % (table, data)
+
diff --git a/tools/file_packager.py b/tools/file_packager.py
index 575e5957..136da609 100644
--- a/tools/file_packager.py
+++ b/tools/file_packager.py
@@ -122,8 +122,6 @@ for arg in sys.argv[1:]:
       srcpath, dstpath = arg.split('@') # User is specifying destination filename explicitly.
     else:
       srcpath = dstpath = arg # Use source path as destination path.
-      if os.path.isabs(dstpath):
-        print >> sys.stderr, 'Warning: Embedding an absolute file/directory name "' + dstpath + '" to the virtual filesystem. The file will be made available in the path "' + dstpath + '", and not in the root of the generated file system. Use the explicit syntax --preload-file srcpath@dstpath to specify the target location the absolute source path should be directed to.'
     if os.path.isfile(srcpath) or os.path.isdir(srcpath):
       data_files.append({ 'srcpath': srcpath, 'dstpath': dstpath, 'mode': mode })
     else:
@@ -198,6 +196,22 @@ for file_ in data_files:
     os.path.walk(file_['srcpath'], add, [file_['mode'], file_['srcpath'], file_['dstpath']])
 data_files = filter(lambda file_: not os.path.isdir(file_['srcpath']), data_files)
 
+# Absolutize paths, and check that they make sense
+curr_abspath = os.path.abspath(os.getcwd())
+for file_ in data_files:
+  if file_['srcpath'] == file_['dstpath']:
+    # This file was not defined with src@dst, so we inferred the destination from the source. In that case,
+    # we require that the destination not be under the current location
+    path = file_['dstpath']
+    abspath = os.path.abspath(path)
+    if DEBUG: print >> sys.stderr, path, abspath, curr_abspath
+    if not abspath.startswith(curr_abspath):
+      print >> sys.stderr, 'Error: Embedding "%s" which is below the current directory. This is invalid since the current directory becomes the root that the generated code will see' % path
+      sys.exit(1)
+    file_['dstpath'] = abspath[len(curr_abspath)+1:]
+    if os.path.isabs(path):
+      print >> sys.stderr, 'Warning: Embedding an absolute file/directory name "' + path + '" to the virtual filesystem. The file will be made available in the relative path "' + file_['dstpath'] + '". You can use the explicit syntax --preload-file srcpath@dstpath to explicitly specify the target location the absolute source path should be directed to.'
+
 for file_ in data_files:
   file_['dstpath'] = file_['dstpath'].replace(os.path.sep, '/') # name in the filesystem, native and emulated
   if file_['dstpath'].endswith('/'): # If user has submitted a directory name as the destination but omitted the destination filename, use the filename from source file
diff --git a/tools/merge_asm.py b/tools/merge_asm.py
new file mode 100755
index 00000000..fe143a89
--- /dev/null
+++ b/tools/merge_asm.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python2
+
+'''
+Splits a compiler outputted program into the asm module and the surrounding shell. This
+can be useful if you want to process the shell in some manner (e.g. minifiy it) in ways
+that would be harmful to asm.js code.
+'''
+
+import sys
+import shared
+
+try:
+  me, in_shell, in_asm, outfile = sys.argv[:4]
+except:
+  print >> sys.stderr, 'usage: emlink.py [input file] [shell output file] [asm output file]'
+  sys.exit(1)
+
+print 'Shell input:', in_shell
+print 'Asm input:', in_asm
+print 'Input file:', outfile
+
+shared.try_delete(outfile)
+
+pre, post = open(in_shell).read().split('// ASM_CODE\n')
+open(outfile, 'w').write(pre + '\n' + open(in_asm).read() + '\n' + post)
+
diff --git a/tools/shared.py b/tools/shared.py
index 007c2ee8..c0df227d 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -286,7 +286,7 @@ def check_node_version():
 EMSCRIPTEN_VERSION = '1.5.3'
 
 def generate_sanity():
-  return EMSCRIPTEN_VERSION + '|' + get_llvm_target()
+  return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + '|' + LLVM_ROOT
 
 def check_sanity(force=False):
   try:
@@ -509,6 +509,7 @@ COMPILER_OPTS = COMPILER_OPTS + ['-m32', '-U__i386__', '-U__i386', '-Ui386',
                                  '-target', LLVM_TARGET]
 
 if LLVM_TARGET == 'le32-unknown-nacl':
+  COMPILER_OPTS = filter(lambda opt: opt != '-m32', COMPILER_OPTS) # le32 target is 32-bit anyhow, no need for -m32
   COMPILER_OPTS += ['-U__native_client__', '-U__pnacl__', '-U__ELF__'] # The nacl target is originally used for Google Native Client. Emscripten is not NaCl, so remove the platform #define, when using their triple.
 
 USE_EMSDK = not os.environ.get('EMMAKEN_NO_SDK')
@@ -516,7 +517,7 @@ USE_EMSDK = not os.environ.get('EMMAKEN_NO_SDK')
 if USE_EMSDK:
   # Disable system C and C++ include directories, and add our own (using -idirafter so they are last, like system dirs, which
   # allows projects to override them)
-  EMSDK_OPTS = ['-nostdinc', '-nostdinc++', '-Xclang', '-nobuiltininc', '-Xclang', '-nostdsysteminc',
+  EMSDK_OPTS = ['-nostdinc', '-Xclang', '-nobuiltininc', '-Xclang', '-nostdsysteminc',
     '-Xclang', '-isystem' + path_from_root('system', 'local', 'include'),
     '-Xclang', '-isystem' + path_from_root('system', 'include', 'libcxx'),
     '-Xclang', '-isystem' + path_from_root('system', 'include'),
@@ -529,9 +530,14 @@ if USE_EMSDK:
   ] + [
     '-U__APPLE__', '-U__linux__'
   ]
+  if LLVM_TARGET != 'le32-unknown-nacl':
+    EMSDK_CXX_OPTS = ['-nostdinc++'] # le32 target does not need -nostdinc++
+  else:
+    EMSDK_CXX_OPTS = []
   COMPILER_OPTS += EMSDK_OPTS
 else:
   EMSDK_OPTS = []
+  EMSDK_CXX_OPTS = []
 
 #print >> sys.stderr, 'SDK opts', ' '.join(EMSDK_OPTS)
 #print >> sys.stderr, 'Compiler opts', ' '.join(COMPILER_OPTS)
@@ -593,7 +599,7 @@ def line_splitter(data):
 
   return out
 
-def limit_size(string, MAX=80*20):
+def limit_size(string, MAX=120*20):
   if len(string) < MAX: return string
   return string[0:MAX/2] + '\n[..]\n' + string[-MAX/2:]
 
diff --git a/tools/split_asm.py b/tools/split_asm.py
new file mode 100755
index 00000000..39eaca00
--- /dev/null
+++ b/tools/split_asm.py
@@ -0,0 +1,30 @@
+#!/usr/bin/env python2
+
+'''
+Splits a compiler outputted program into the asm module and the surrounding shell. This
+can be useful if you want to process the shell in some manner (e.g. minifiy it) in ways
+that would be harmful to asm.js code.
+'''
+
+import sys
+import shared
+from asm_module import AsmModule
+
+try:
+  me, infile, out_shell, out_asm = sys.argv[:4]
+except:
+  print >> sys.stderr, 'usage: emlink.py [input file] [shell output file] [asm output file]'
+  sys.exit(1)
+
+print 'Input file:', infile
+print 'Shell output:', out_shell
+print 'Asm output:', out_asm
+
+shared.try_delete(out_shell)
+shared.try_delete(out_asm)
+
+module = AsmModule(infile)
+
+open(out_shell, 'w').write(module.pre_js + '\n// ASM_CODE\n' + module.post_js)
+open(out_asm, 'w').write(module.asm_js)
+