v110

Corrections for IOKit joypad driver [Sintendo]

.cirrus.yml

@@ -0,0 +1,81 @@
+linux-x86_64-binaries_task:
+    container:
+        image: ubuntu:latest
+
+    setup_script:
+        - apt-get update && apt-get -y install build-essential libgtk2.0-dev libpulse-dev mesa-common-dev libgtksourceview2.0-dev libcairo2-dev libsdl2-dev libxv-dev libao-dev libopenal-dev libudev-dev zip
+
+    compile_script:
+        - make -C bsnes local=false
+
+    package_script:
+        - mkdir bsnes-nightly
+        - mkdir bsnes-nightly/Database
+        - mkdir bsnes-nightly/Firmware
+        - cp -a bsnes/out/bsnes bsnes-nightly/bsnes
+        - cp -a bsnes/Database/* bsnes-nightly/Database
+        - cp -a GPLv3.txt bsnes-nightly
+        - zip -r bsnes-nightly.zip bsnes-nightly
+
+    bsnes-nightly_artifacts:
+        path: "bsnes-nightly.zip"
+
+freebsd-x86_64-binaries_task:
+    freebsd_instance:
+        image: freebsd-12-0-release-amd64
+
+    setup_script:
+        - pkg install --yes gmake gdb gcc8 pkgconf sdl2 openal-soft gtksourceview2 libXv zip
+
+    compile_script:
+        - gmake -C bsnes local=false
+
+    package_script:
+        - mkdir bsnes-nightly
+        - mkdir bsnes-nightly/Database
+        - mkdir bsnes-nightly/Firmware
+        - cp -a bsnes/out/bsnes bsnes-nightly/bsnes
+        - cp -a bsnes/Database/* bsnes-nightly/Database
+        - cp -a GPLv3.txt bsnes-nightly
+        - zip -r bsnes-nightly.zip bsnes-nightly
+
+    bsnes-nightly_artifacts:
+        path: "bsnes-nightly.zip"
+
+windows-x86_64-binaries_task:
+    container:
+        image: ubuntu:latest
+
+    setup_script:
+        - apt-get update && apt-get -y install build-essential mingw-w64 zip
+
+    compile_script:
+        - make -C bsnes local=false platform=windows compiler="x86_64-w64-mingw32-g++" windres="x86_64-w64-mingw32-windres"
+
+    package_script:
+        - mkdir bsnes-nightly
+        - mkdir bsnes-nightly/Database
+        - mkdir bsnes-nightly/Firmware
+        - cp -a bsnes/out/bsnes bsnes-nightly/bsnes.exe
+        - cp -a bsnes/Database/* bsnes-nightly/Database
+        - cp -a GPLv3.txt bsnes-nightly
+        - zip -r bsnes-nightly.zip bsnes-nightly
+
+    bsnes-nightly_artifacts:
+        path: "bsnes-nightly.zip"
+
+macOS-x86_64-binaries_task:
+    osx_instance:
+        image: mojave-base
+
+    compile_script:
+        - make -C bsnes local=false
+
+    package_script:
+        - mkdir bsnes-nightly
+        - cp -a bsnes/out/bsnes.app bsnes-nightly
+        - cp -a GPLv3.txt bsnes-nightly
+        - zip -r bsnes-nightly.zip bsnes-nightly
+
+    bsnes-nightly_artifacts:
+        path: "bsnes-nightly.zip"

.github/FUNDING.yml

@@ -0,0 +1 @@
+patreon: byuu

.gitignore

@@ -1,3 +0,0 @@
-higan/profile/WonderSwan.sys/internal.ram
-higan/profile/WonderSwan Color.sys/internal.ram
-docs_build/

.gitlab-ci.yml

@@ -1,59 +0,0 @@
-# NOTE: This file is not part of the official higan source, it's been added
-# to help build WIP binaries with minimal fuss.
-
-image: debian:stable
-
-linux-x86_64-binaries:
-  script:
-    - apt-get update && apt-get -y install build-essential libgtk2.0-dev libpulse-dev mesa-common-dev libgtksourceview2.0-dev libcairo2-dev libsdl1.2-dev libxv-dev libao-dev libopenal-dev libudev-dev mkdocs
-    - make -C icarus compiler=g++
-    - make -C higan compiler=g++
-    - LC_ALL=C.UTF-8 mkdocs build
-    - mkdir higan-nightly
-    - cp -a icarus/out/icarus higan-nightly/icarus
-    - cp -a icarus/Database higan-nightly/
-    - cp -a higan/out/higan higan-nightly/higan
-    - cp -a higan/systems/* higan-nightly/
-    - cp -a shaders "higan-nightly/Video Shaders"
-    - cp -a docs_build higan-nightly/docs
-    - cp -a GPLv3.txt higan-nightly/
-  artifacts:
-    paths:
-      - higan-nightly/*
-
-windows-x86_64-binaries:
-  # This is a normal Windows cross-compile process, except that
-  # nall::chrono tries to use clock_gettime on Windows even
-  # though it's a POSIX function, and for some weird reason mingw has
-  # clock_gettime() in the pthread library.
-  script:
-    - apt-get update && apt-get -y install build-essential mingw-w64 mkdocs
-    - sed -i -e 's/-lole32/& -static -lpthread/' nall/GNUmakefile
-    - make -C icarus platform=windows compiler="x86_64-w64-mingw32-g++ -static-libgcc -static-libstdc++" windres="x86_64-w64-mingw32-windres"
-    - make -C higan platform=windows compiler="x86_64-w64-mingw32-g++ -static-libgcc -static-libstdc++" windres="x86_64-w64-mingw32-windres"
-    - LC_ALL=C.UTF-8 mkdocs build
-    - mkdir higan-nightly
-    - cp -a icarus/out/icarus higan-nightly/icarus.exe
-    - cp -a icarus/Database higan-nightly/
-    - cp -a higan/out/higan higan-nightly/higan.exe
-    - cp -a higan/systems/* higan-nightly/
-    - cp -a shaders "higan-nightly/Video Shaders"
-    - cp -a docs_build higan-nightly/docs
-    - cp -a GPLv3.txt higan-nightly/
-  artifacts:
-    paths:
-      - higan-nightly/*
-
-libretro-test:
-  script:
-    - apt-get update && apt-get -y install build-essential git
-    # git refuses to even attempt a merge if you haven't told it who you are,
-    # even if you use --no-commit. *sigh*
-    - EMAIL=fake-email@example.com git merge origin/libretro
-    - make -C higan compiler=g++ binary=library target=libretro
-    - mkdir libretro-nightly
-    - cp -a higan/out/higan_sfc_libretro.so libretro-nightly/
-    - cp -a GPLv3.txt libretro-nightly/
-  artifacts:
-    paths:
-      - libretro-nightly/*

CONTRIBUTING.md

@@ -1,9 +0,0 @@
-Contributing to higan
-=====================
-
-If you would like to propose a change to higan,
-you should create an account on the [official forums][f],
-go to the "Projects" forum and the "higan" sub-forum,
-and post your idea in a new topic there.
-
-[f]: https://board.byuu.org/

LICENSE.txt

@@ -1,10 +1,9 @@
 ----------------------------------------------------------------------
-higan  - Suite of videogame console emulators
-icarus - Game library importer for higan
+bsnes - Super Nintendo emulator
 
-  Copyright © 2004-2017  byuu
+  Copyright © 2004-2019 byuu
 
-  https://byuu.org/
+  https://byuu.org
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -21,12 +20,12 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 ----------------------------------------------------------------------
 
 ----------------------------------------------------------------------
-hiro   - User interface toolkit
-libco  - C cooperative threading library
-nall   - C++ template library
-ruby   - Hardware abstraction layer
+libco - C cooperative threading library
+nall  - C++ template library
+ruby  - Hardware abstraction library
+hiro  - User interface library
 
-  Copyright © 2006-2017  byuu
+  Copyright © 2006-2019 byuu
 
 Permission to use, copy, modify, and/or distribute this software for
 any purpose with or without fee is hereby granted, provided that the

README.md

@@ -1,48 +1,81 @@
-The unofficial higan repository
-===============================
+bsnes
+=====
 
-higan emulates a number of classic video-game consoles of the 1980s and 1990s,
-allowing you to play classic games on a modern general-purpose computer.
+bsnes is a multi-platform Super Nintendo (Super Famicom) emulator that focuses
+on performance, features, and ease of use.
 
-This repository includes
-the source-code for
-stable and WIP releases of higan,
-starting during the development of v068.
-It also includes community-maintained documentation.
+bsnes currently enjoys 100% known, bug-free compatibility with the entire SNES
+library when configured to its most accurate settings, giving it the same
+accuracy level as higan. Accuracy can also optionally be traded for performance,
+allowing bsnes to operate more than 300% faster than higan while still remaining
+almost as accurate.
 
-Basically,
-apart from `.gitignore` files,
-anything in the
-[higan](higan/),
-[hiro](hiro/),
-[icarus](icarus/),
-[libco](libco/),
-[nall](nall/),
-[ruby](ruby/),
-or [shaders](shaders/)
-directories should be exactly as it appeared in official releases.
-Everything else has been added for various reasons.
+Development
+-----------
 
-Official higan resources
-------------------------
+Git is used for the development of new releases, and represents a staging
+environment. As bsnes is rather mature, things should generally be quite stable.
+However, bugs will exist, regressions will occur, so proceed at your own risk.
 
-  - [Official homepage](https://byuu.org/emulation/higan/)
-  - [Official forum](https://board.byuu.org/viewforum.php?f=4)
+If stability is required, please download the latest stable release from the
+[official website.](https://bsnes.byuu.org)
 
-Unofficial higan resources
---------------------------
+Unique Features
+---------------
 
-  - Documentation for
-    [the current stable version][stadocs]
-  - [Source code repository](https://gitlab.com/higan/higan/)
-    archives official higan releases
-    and WIP snapshots
-    since approximately v067r21
-  - [Latest WIP build for Windows][wipwin]
-  - Documentation for
-    [the latest WIP version][wipdocs]
+  - 100% (known) bug-free compatibility with the entire officially licensed SNES games library
+  - True Super Game Boy emulation (using the SameBoy core by Lior Halphon)
+  - HD mode 7 graphics with optional supersampling (by DerKoun)
+  - Low-level emulation of all SNES coprocessors (DSP-n, ST-01n, Cx4)
+  - Multi-threaded PPU graphics renderer
+  - Speed mode settings which retain smooth audio output (50%, 75%, 100%, 150%, 200%)
+  - Built-in games database with thousands of game entries
+  - Built-in cheat code database for hundreds of popular games (by mightymo)
+  - Built-in save state manager with screenshot previews and naming capabilities
+  - Support for ASIO low-latency audio
+  - Customizable per-byte game mappings to support any cartridges, including prototype games
+  - 7-zip decompression support
+  - Extensive Satellaview emulation, including BS Memory flash write and wear-leveling emulation
+  - 30-bit color output support (where supported)
+  - Optional higan game folder support (standard game ROM files are also fully supported!)
 
+Standard Features
+-----------------
 
-[wipwin]: https://gitlab.com/higan/higan/-/jobs/artifacts/master/download?job=windows-x86_64-binaries
-[stadocs]: https://higan.readthedocs.io/
-[wipdocs]: https://higan.readthedocs.io/en/latest/
+  - MSU1 support
+  - BPS and IPS soft-patching support
+  - Save states with undo and redo support (for reverting accidental saves and loads)
+  - OpenGL multi-pass pixel shaders
+  - Several built-in software filters, including HQ2x (by MaxSt) and snes_ntsc (by blargg)
+  - Adaptive sync and dynamic rate control for perfect audio/video synchronization
+  - Just-in-time input polling for minimal input latency
+  - Support for Direct3D exclusive mode video
+  - Support for WASAPI exclusive mode audio
+  - Periodic auto-saving of game saves
+  - Auto-saving of states when unloading games, and auto-resuming of states when reloading games
+  - Sprite limit disable support
+  - Cubic audio interpolation support
+  - Optional high-level emulation of most SNES coprocessors
+  - CPU, SA1, and SuperFX overclocking support
+  - Frame advance support
+  - Screenshot support
+  - Cheat code search support
+  - Movie recording and playback support
+  - Rewind support
+  - HiDPI support
+
+Links
+-----
+
+  - [Official website](https://bsnes.byuu.org)
+  - [Official git repository](https://github.com/byuu/bsnes)
+  - [Donations](https://patreon.com/byuu)
+
+Nightly Builds
+--------------
+
+  - [Download](https://cirrus-ci.com/github/byuu/bsnes/master)
+  - ![Build status](https://api.cirrus-ci.com/github/byuu/bsnes.svg?task=windows-x86_64-binaries)
+  - ![Build status](https://api.cirrus-ci.com/github/byuu/bsnes.svg?task=macOS-x86_64-binaries)
+  - ![Build status](https://api.cirrus-ci.com/github/byuu/bsnes.svg?task=linux-x86_64-binaries)
+  - ![Build status](https://api.cirrus-ci.com/github/byuu/bsnes.svg?task=freebsd-x86_64-binaries)

README.txt

@@ -1,294 +0,0 @@
-
-higan - "Now you're playing with fire!"
-=======================================
-
-higan is a multi-system emulator that began development on October 14th, 2004.
-It currently plays games for the following systems:
-
-   * Nintendo Famicom (NES), Super Famicom (SNES)
-   * Nintendo Game Boy, Game Boy Color + Game Boy Advance
-   * Sega Master System, Game Gear + Mega Drive (Genesis)
-   * NEC PC Engine (TurboGrafx) + SuperGrafx
-   * Bandai WonderSwan + WonderSwan Color
-
-
-Supported Systems
------------------
-
-   * FreeBSD 10+
-   * Windows 7, 8, 10
-   * Linux 3.2+
-   * OS X 10.7 Lion or above
-
-You'll need a fast CPU, with clock speed being vastly more important.
-Dual-core is perfectly adequate, since higan doesn't make significant use
-of more than one core.
-
-For Intel, you're looking at a 3.5 GHz Haswell architecture or better,
-whilst AMD users will want a similarly specced Ryzen build.
-
-
-Controller Setup
-----------------
-
-First, you'll want to configure your controllers. Choose Settings -> Input and
-pick the system you'd like to configure. If you have two players, or a special
-game (eg. Mario Paint), you can pick the controller port and device here.
-
-To assign inputs, double click the name and press the stick or button on your
-controller. You can have multiple assignments, for example both keyboard and
-joypad. The Erase button clears the assignments for one input; Reset clears
-them all in one go.
-
-   (Normally you only need to do this once. But because of how USB works,
-   it's impossible to tell identical controllers apart. This means if you move
-   one to another port, it counts as a new device, and you'll have to reassign
-   the buttons or move it back.)
-
-
-Loading Games
--------------
-
-After this you can go to Library -> Load ROM File and select a game. higan
-adds it to your library, and it should start immediately. (Game Boy Advance
-titles need one more step; please see the FAQ below.)
-
-To add games en masse, you can use Library -> Import ROM Files. This opens
-icarus, where you can choose a folder of ROMs, then select the ones you want
-to import.
-
-In both cases, if you choose a system under the Library submenus, all games
-added will show up in a file browser under the Emulation folder in your user
-profile. The path can be changed under Settings -> Advanced if desired.
-
-
-Controller Ports
-----------------
-
-If you're emulating a console, you need to plug the controllers in, since
-there's no connection by default.
-
-Usually this means selecting eg. Super Famicom -> Controller Port 1 -> Gamepad,
-for example. However, some games require other peripherals like the SNES Mouse.
-
-
-Troubleshooting & FAQ
----------------------
-
-Q: What's the Library?
-
-A: higan loads folders containing all the files needed to run the game.
-   Odds are you have PC games and music albums organised the same way.
-   This does mean that to play the games, you have to import them first.
-   
-   If you're familiar with iTunes or Steam, you already know how this works!
-
-
-Q: Importing vs. loading? What's the difference?
-
-A: The "Library -> Load ROM File" menu is a shortcut. It adds the game to your
-   library, then opens it without the manual import process.
-   
-   However, if you have lots of games to add at once, you'll want
-   "Import ROM Files" instead.
-
-
-Q: Why's higan say I'm missing a file ("Game Boy Advance.sys/bios.rom")?
-
-A: This is the ROM for the startup screen you see when you switch on the
-   Game Boy Advance. Games require it to run, but like other ROMs, it's
-   copyrighted and therefore not provided with higan.
-   
-   Having acquired a copy, you'll have to drop it in the requested folder,
-   then rename it to bios.rom.
-
-
-Q: Where are the games imported? Where did all my save files go?
-
-A: Check the path under Settings -> Advanced. On Windows it'll probably be
-   something like C:\Users\<name>\Emulation, organised by system. The saves
-   are typically named save.ram.
-
-
-Q: Where can I find the settings?
-
-A: There's a few possible locations for settings.bml.
-   
-   1) In the same folder as the higan executable.
-   
-   2) In the older location if you previously installed higan:
-      
-      C:\Users\<name>\AppData\Roaming\higan            (Windows)
-      /home/<name>/.config/higan                       (BSD, Linux)
-   
-   3) In the new location (created if the others aren't found):
-      
-      C:\Users\<name>\AppData\Local\higan              (Windows)
-      /home/<name>/.local/share/higan                  (BSD, Linux)
-      /Users/<name>/Library/Application Support/higan  (Mac)
-   
-   higan checks these in order, so you can make a portable install if you like.
-   
-      (macOS normally hides the Library folder. To open it, switch to Finder,
-      hold the Option key and select Go -> Library from the menu.)
-
-
-Q: I set up my gamepads, but they don't work!
-
-A: Try configuring the ports found in the system menu (eg.
-   Super Famicom -> Controller Port 1 -> Gamepad). Like a real console,
-   fresh higan installs come without any controllers plugged in.
-
-
-Q: I upgraded higan, why do I get a black screen? What's "Ignore Manifests?"
-
-A: higan looks at a file called "manifest.bml" to get the information needed
-   to run each game. However, the format has changed over time, making older
-   manifests incompatible with newer higan releases.
-   
-   If you tick "Settings -> Advanced -> Ignore Manifests," you might find this
-   resolves the problem. This can be useful for developers and testers.
-   However, it breaks a few titles that require manifests to work!
-   
-   Should you find yourself in this situation, consider removing manifest.bml.
-   
-      (By default, no manifests are created; higan looks at the files in the
-      game folder, and with the help of a database, tries to regenerate the
-      correct one each time you load the game.)
-
-
-Q: I have "Ignore Manifests" ticked, but the game won't run?
-
-A: A few games have especially quirky setups that require manifests for
-   the time being, so you'll need to untick this option:
-   
-      * Far East of Eden: Tengai Makyou Zero  (English translation only)
-      * Campus Challenge '92
-      * PowerFest '94
-
-
-Q: Why's the audio lag, stutter, distort, or sound robotic?
-
-A: If you have an Atom, certain Celeron models, or an older AMD processor
-   (or even an especially old Intel such as a Core 2 Duo)... then these aren't
-   fast enough, sorry. :(
-   
-   Try going into the Settings -> Advanced menu, then pick a different audio
-   driver and restart higan. WASAPI can be fussy on some devices.
-   
-   Select Settings -> Audio and experiment with the latency. Larger values
-   should be more reliable, with the downside of laggier game controls.
-   
-   Occasionally software that hooks into the system or other apps, for example
-   mouse settings panels, can cause lag and other problems.
-   
-   Because higan is CPU-intensive and single-threaded, it can interact badly
-   with video capture which is yet another burden on the system. If you're
-   trying to stream or broadcast, and you have Windows 7, consider disabling
-   DWM. Also, look up how to configure hardware encoding (eg. QuickSync).
-
-
-Q: Can I get smoother video?
-
-A: Try Settings -> Video -> Exclusive mode, then switch to fullscreen. This
-   currently requires the Direct3D video driver under Settings -> Advanced
-   in order to work.
-   
-      (Exclusive fullscreen is pretty experimental at the moment.
-      There are cases where it fails badly, so save your work!)
-
-   Exclusive mode will normally yield what's known as "tearing." If this
-   bothers you, there's an alternative... albeit one with serious gotchas,
-   which is why it's hidden away.
-   
-   Close higan, then open up settings.bml and look for the following:
-   
-      Video
-        Driver:Direct3D
-        Synchronize:false
-        ...
-   
-   Change false to true, save the file, then start higan and untick
-   Settings -> Synchronize Audio.
-   
-   Keep in mind that this setting can and will reduce sound quality, as GPUs
-   and sound cards in modern PCs generally are not synchronised with each
-   other. The second big consideration is that your refresh rate needs to
-   match the game.
-   
-   PAL and NTSC titles run at 50 Hz and 60 Hz, respectively. This applies to
-   all console systems. Of the handhelds: Game Boy, Game Boy Color and
-   Game Boy Advance run at 60 Hz, while WonderSwan runs at 75 Hz.
-   
-   This means you'll need a monitor that supports these frequencies, set to
-   the appropriate display mode. Not all of them do. If your refresh rate
-   doesn't match, games will run at the wrong speed.
-
-
-Online Resources
-----------------
-
-Official homepage + forum:
-
-   https://byuu.org/emulation/higan
-   https://board.byuu.org/viewforum.php?f=4
-
-Unoffical source code repository + documentation:
-
-   https://gitlab.com/higan/higan
-   https://higan.readthedocs.io
-
-Info on game folders and firmware:
-
-   https://byuu.org/emulation/higan/game-paks
-   https://byuu.org/emulation/higan/firmware
-
-Donations:
-
-   https://patreon.com/byuu
-
-Commercial use:
-
-   https://byuu.org/emulation/higan/licensing
-
-
-Credits
--------
-
-Original author:
-
-   byuu
-
-We'd like to acknowledge many invaluable contributions made to higan
-by the following individuals:
-
-   Andreas Naive         Hendricks266          Overload
-   Ange Albertini        hex_usr               p4plus2
-   anomie                jchadwick             quequotion
-   AWJ                   Jonas Quinn           RedDwarf
-   Bisqwit               kode54                Richard Bannister
-   blargg                krom                  Ryphecha
-   Łukasz Krawczyk       Lioncash              segher
-   Cydrak                Lord Nightmare        Sintendo
-   Danish                lowkey                SuperMikeMan
-   DMV27                 MerryMage             tetsuo55
-   Dr. Decapitator       Matthew Callis        TmEE
-   endrift               mightymo              TRAC
-   Fatbag                Nach                  wareya
-   FitzRoy               ncbncb                zones
-   gekkio                neviksti
-   GIGO                  OV2
-
-It's been a long, wild ride... apologies to anyone we've missed!
-
-For more information, please see:
-
-   https://board.byuu.org/viewtopic.php?f=4&t=1631&p=41575#p41575
-
-
-License
--------
-
-higan is provided under the GNU General Public License, version 3.
-However, certain libraries may be used under the more permissive ISC license.
-Please see LICENSE.txt for details.

bsnes/Database/BS Memory.bml

@@ -0,0 +1,44 @@
+database
+  revision: 2018-09-20
+
+//BS Memory (JPN)
+
+database
+  revision: 2018-04-14
+
+game
+  sha256:   80c34b50817d58820bc8c88d2d9fa462550b4a76372e19c6467cbfbc8cf5d9ef
+  label:    鮫亀 キャラカセット
+  name:     Same Game - Chara Cassette
+  region:   BSMC-ZS5J-JPN
+  revision: BSMC-ZS5J-0
+  board:    BSMC-CR-01
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+
+game
+  sha256:   859c7f7b4771d920a5bdb11f1d247ab6b43fb026594d1062f6f72d32cd340a0a
+  label:    鮫亀 キャラデータ集
+  name:     Same Game - Chara Data Shuu
+  region:   BSMC-YS5J-JPN
+  revision: BSMC-YS5J-0
+  board:    BSMC-CR-01
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+
+game
+  sha256:   c92a15fdd9b0133f9ea69105d0230a3acd1cdeef98567462eca86ea02a959e4e
+  label:    SDガンダム ジーネクスト ユニット&マップコレクション
+  name:     SD Gundam G Next - Unit & Map Collection
+  region:   BSMC-ZX3J-JPN
+  revision: BSMC-ZX3J-0
+  board:    BSMC-BR-01
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+

bsnes/Database/Sufami Turbo.bml

@@ -0,0 +1,213 @@
+database
+  revision: 2018-09-20
+
+//Sufami Turbo (JPN)
+
+database
+  revision: 2018-04-14
+
+game
+  sha256:   f73bda08743565e0bd101632ebbac2d363d703a3ab39d23f49d95217cab29269
+  label:    美少女戦士セーラームーン セーラースターズ ふわふわパニック2
+  name:     Bishoujo Senshi Sailor Moon Sailor Stars - Fuwafuwa Panic 2
+  region:   SFT-0112-JPN
+  revision: SAILOR MOON
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x100000
+      content: Program
+  note: Unlinkable
+
+game
+  sha256:   afb3f2a83b5bfcb1b8829b6995f108cc4d64ca322d1ba4a50b83af6e1f2e89bd
+  label:    クレヨンしんちゃん 長ぐつドボン!!
+  name:     Crayon Shin-chan - Nagagutsu Dobon!!
+  region:   SFT-0113-JPN
+  revision: SHINCYAN
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+  note: Unlinkable
+
+game
+  sha256:   d93b3a570e7cf343f680ab0768a50b77e3577f9c555007e2de3decd6bc4765c8
+  label:    ゲゲゲの鬼太郎 妖怪ドンジャラ
+  name:     Gegege no Kitarou - Youkai Donjara
+  region:   SFT-0106-JPN
+  revision: KITARO DONJYAR
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+  note: Unlinkable
+
+game
+  sha256:   89aecd4e23d8219c8de3e71bb75db3dfe667d51c1eba4ea7239d2f772743d0cc
+  label:    激走戦隊カーレンジャ 全開!レーサー戦士
+  name:     Gekisou Sentai Carranger - Zenkai! Racer Senshi
+  region:   SFT-0109-JPN
+  revision: CAR RANGER
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+  note: Unlinkable
+
+game
+  sha256:   602b20b788640f5743487108a10f3f77bca5ce2d24208b25b1ca498a96eb0d69
+  label:    ぽいぽい忍者ワールド
+  name:     Poi Poi Ninja World
+  region:   SFT-0103-JPN
+  revision: POI POI NINJYA
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x800
+      content: Save
+  note: Linkable: SFT-0103-JPN
+
+game
+  sha256:   2a9d7c9a61318861028a73ca03e32a48cff162d76cba36fbaab8690b212efe9b
+  label:    SDガンダムジェネレーション アクシズ戦記
+  name:     SD Gundam Generation - Axis Senki
+  region:   SFT-0107-JPN
+  revision: GUNDAM C
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   60ac017c18f534e8cf24ca7f38e22ce92db95ea6c30b2d59d76f13c4f1c8a6e4
+  label:    SDガンダムジェネレーション バビロニア建国戦記
+  name:     SD Gundam Generation - Babylonia Kenkoku Senki
+  region:   SFT-0108-JPN
+  revision: GUNDAM D
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   e639b5d5d722432b6809ccc6801dc584e1a3016379f34b335ed2dfa73b1ebf69
+  label:    SDガンダムジェネレーション コロニー格闘記
+  name:     SD Gundam Generation - Colony Kakutouki
+  region:   SFT-0111-JPN
+  revision: GUNDAM F
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   8547a08ed11fe408eac282a90ac46654bd2e5f49bda3aec8e5edf166a0a4b9af
+  label:    SDガンダムジェネレーション グリプス戦記
+  name:     SD Gundam Generation - Gryps Senki
+  region:   SFT-0105-JPN
+  revision: GUNDAM B
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   3e82215bed08274874b30d461fc4a965c6bca932229da5d46d56e36f484d65eb
+  label:    SDガンダムジェネレーション 一年戦争記
+  name:     SD Gundam Generation - Ichinen Sensouki
+  region:   SFT-0104-JPN
+  revision: GUNDAM A
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   5951a58a91d8e397d0a237ccc2b1248e17c7312cb9cc11cbc350200a97b4e021
+  label:    SDガンダムジェネレーション ザンスカール戦記
+  name:     SD Gundam Generation - Zanscare Senki
+  region:   SFT-0110-JPN
+  revision: GUNDAM E
+  board:    PT-912
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x2000
+      content: Save
+  note: Linkable: SFT-0104-JPN, SFT-0105-JPN, SFT-0107-JPN, SFT-0108-JPN, SFT-0110-JPN, SFT-0111-JPN
+
+game
+  sha256:   2fec5f2bc7dee010af10569a3d2bc18715a79a126940800c3eade5abbd625e3f
+  label:    SDウルトラバトル セブン伝説
+  name:     SD Ultra Battle - Seven Densetsu
+  region:   SFT-0102-JPN
+  revision: ULTRA SEVEN 1
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x800
+      content: Save
+  note: Linkable: SFT-0101-JPN, SFT-0102-JPN
+
+game
+  sha256:   2bb55214fb668ca603d7b944b14f105dfb10b987a8902d420fe4ae1cb69c1d4a
+  label:    SDウルトラバトル ウルトラマン伝説
+  name:     SD Ultra Battle - Ultraman Densetsu
+  region:   SFT-0101-JPN
+  revision: ULTRA MAN 1
+  board:    PT-911
+    memory
+      type: ROM
+      size: 0x80000
+      content: Program
+    memory
+      type: RAM
+      size: 0x800
+      content: Save
+  note: Linkable: SFT-0101-JPN, SFT-0102-JPN
+

bsnes/GNUmakefile

@@ -0,0 +1,66 @@
+target := bsnes
+binary := application
+build := performance
+openmp := true
+local := true
+flags += -I. -I..
+
+# in order for this to work, obj/lzma.o must be omitted or bsnes will hang on startup.
+# further, only the X-Video driver works reliably. OpenGL 3.2, OpenGL 2.0, and XShm crash bsnes.
+ifeq ($(profile),true)
+  flags += -pg
+  options += -pg
+endif
+
+# binaries built with this flag are faster, but are not portable to multiple machines.
+ifeq ($(local),true)
+  flags += -march=native
+endif
+
+nall.path := ../nall
+include $(nall.path)/GNUmakefile
+
+ifeq ($(platform),windows)
+  ifeq ($(binary),application)
+    options += -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32
+    options += -Wl,-enable-auto-import
+    options += -Wl,-enable-runtime-pseudo-reloc
+  else ifeq ($(binary),library)
+    options += -shared
+  endif
+else ifeq ($(platform),macos)
+  ifeq ($(binary),application)
+  else ifeq ($(binary),library)
+    flags += -fPIC
+    options += -dynamiclib
+  endif
+else ifneq ($(filter $(platform),linux bsd),)
+  ifeq ($(binary),application)
+    options += -Wl,-export-dynamic
+    options += -lX11 -lXext
+  else ifeq ($(binary),library)
+    flags += -fPIC
+    options += -shared
+  endif
+else
+  $(error "unsupported platform")
+endif
+
+objects := libco emulator filter lzma
+
+obj/libco.o: ../libco/libco.c
+obj/emulator.o: emulator/emulator.cpp
+obj/filter.o: filter/filter.cpp
+obj/lzma.o: lzma/lzma.cpp
+
+include sfc/GNUmakefile
+include gb/GNUmakefile
+include processor/GNUmakefile
+
+ui := target-$(target)
+include $(ui)/GNUmakefile
+-include obj/*.d
+
+clean:
+	$(call delete,obj/*)
+	$(call delete,out/*)

bsnes/Locale/Japanese.bml

@@ -0,0 +1,127 @@
+locale
+  language: 日本語
+
+namespace: MessageDialog
+  map
+    input: Yes
+    value: はい
+  map
+    input: No
+    value: いいえ
+  map
+    input: Cancel
+    value: キャンセル
+
+namespace: BrowserDialog
+  map
+    input: Open
+    value: 開く
+  map
+    input: Save
+    value: 保存
+  map
+    input: Select
+    value: 選択
+  map
+    input: Cancel
+    value: キャンセル
+
+namespace: Program
+  map
+    input: Unloaded
+    value: アンロードされる
+  map
+    input: Paused
+    value: ポーズ
+
+namespace: Presentation
+  map
+    input: System
+    value: システム
+  map
+    input: Load Game
+    value: ゲームを読み込み
+  map
+    input: Load Recent Game
+    value: 最新ゲームを読み込み
+  map
+    input: empty
+    value: なし
+  map
+    input: Clear List
+    value: 全部を消す
+  map
+    input: Reset System
+    value: システムをリセット
+  map
+    input: Unload Game
+    value: ゲームをアンロード
+  map
+    input: Controller Port 1
+    value: コントローラポート1
+  map
+    input: Controller Port 2
+    value: コントローラポート2
+  map
+    input: Expansion Port
+    value: 拡張ポート
+  map
+    input: Gamepad
+    value: ゲームパッド
+  map
+    input: Mouse
+    value: マウス
+  map
+    input: Super Multitap
+    value: スーパーマルチタップ
+  map
+    input: Super Scope
+    value: スーパースコップ
+  map
+    input: Justifier
+    value: 1挺のジャスティファイアー
+  map
+    input: Justifiers
+    value: 2挺のジャスティファイアー
+  map
+    input: None
+    value: なし
+  map
+    input: Satellaview
+    value: サテラビュー
+  map
+    input: Quit
+    value: 終了
+  map
+    input: Settings
+    value: 設定
+  map
+    input: Tools
+    value: ツール
+  map
+    input: Help
+    value: ヘルプ
+  map
+    input: Documentation
+    value: オンラインマニュアル
+  map
+    input: About
+    value: 情報
+
+namespace: AboutWindow
+  map
+    input: About {0}
+    value: {0}について
+  map
+    input: Version
+    value: バージョン
+  map
+    input: Author
+    value: 作者
+  map
+    input: License
+    value: ライセンス
+  map
+    input: Website
+    value: 公式サイト
+

bsnes/emulator/audio/audio.cpp

@@ -0,0 +1,75 @@
+#define double float
+
+namespace Emulator {
+
+#include "stream.cpp"
+Audio audio;
+
+Audio::~Audio() {
+  reset(nullptr);
+}
+
+auto Audio::reset(Interface* interface) -> void {
+  _interface = interface;
+  _streams.reset();
+  _channels = 0;
+}
+
+auto Audio::setFrequency(double frequency) -> void {
+  _frequency = frequency;
+  for(auto& stream : _streams) {
+    stream->setFrequency(stream->inputFrequency, frequency);
+  }
+}
+
+auto Audio::setVolume(double volume) -> void {
+  _volume = volume;
+}
+
+auto Audio::setBalance(double balance) -> void {
+  _balance = balance;
+}
+
+auto Audio::createStream(uint channels, double frequency) -> shared_pointer<Stream> {
+  _channels = max(_channels, channels);
+  shared_pointer<Stream> stream = new Stream;
+  stream->reset(channels, frequency, _frequency);
+  _streams.append(stream);
+  return stream;
+}
+
+auto Audio::process() -> void {
+  while(_streams) {
+    for(auto& stream : _streams) {
+      if(!stream->pending()) return;
+    }
+
+    double samples[_channels];
+    for(auto& sample : samples) sample = 0.0;
+
+    for(auto& stream : _streams) {
+      double buffer[_channels];
+      uint length = stream->read(buffer), offset = 0;
+
+      for(auto& sample : samples) {
+        sample += buffer[offset];
+        if(++offset >= length) offset = 0;
+      }
+    }
+
+    for(auto c : range(_channels)) {
+      samples[c] = max(-1.0, min(+1.0, samples[c] * _volume));
+    }
+
+    if(_channels == 2) {
+      if(_balance < 0.0) samples[1] *= 1.0 + _balance;
+      if(_balance > 0.0) samples[0] *= 1.0 - _balance;
+    }
+
+    platform->audioFrame(samples, _channels);
+  }
+}
+
+}
+
+#undef double

bsnes/emulator/audio/audio.hpp

@@ -1,5 +1,7 @@
 #pragma once
+#define double float
 
+#include <nall/dsp/iir/dc-removal.hpp>
 #include <nall/dsp/iir/one-pole.hpp>
 #include <nall/dsp/iir/biquad.hpp>
 #include <nall/dsp/resampler/cubic.hpp>
@@ -12,41 +14,43 @@ struct Filter;
 struct Stream;
 
 struct Audio {
-  auto reset(maybe<uint> channels = nothing, maybe<double> frequency = nothing) -> void;
-  auto setInterface(Interface* interface) -> void;
+  ~Audio();
+  auto reset(Interface* interface) -> void;
+
+  inline auto channels() const -> uint { return _channels; }
+  inline auto frequency() const -> double { return _frequency; }
+  inline auto volume() const -> double { return _volume; }
+  inline auto balance() const -> double { return _balance; }
 
   auto setFrequency(double frequency) -> void;
   auto setVolume(double volume) -> void;
   auto setBalance(double balance) -> void;
-  auto setReverb(bool enabled) -> void;
 
   auto createStream(uint channels, double frequency) -> shared_pointer<Stream>;
 
 private:
   auto process() -> void;
 
-  Interface* interface = nullptr;
-  vector<shared_pointer<Stream>> streams;
+  Interface* _interface = nullptr;
+  vector<shared_pointer<Stream>> _streams;
 
-  uint channels = 0;
-  double frequency = 0.0;
+  uint _channels = 0;
+  double _frequency = 48000.0;
 
-  double volume = 1.0;
-  double balance = 0.0;
-
-  bool reverbEnable = false;
-  vector<vector<queue<double>>> reverb;
+  double _volume = 1.0;
+  double _balance = 0.0;
 
   friend class Stream;
 };
 
 struct Filter {
-  enum class Order : uint { First, Second };
-  enum class Type : uint { LowPass, HighPass };
+  enum class Mode : uint { DCRemoval, OnePole, Biquad } mode;
+  enum class Type : uint { None, LowPass, HighPass } type;
+  enum class Order : uint { None, First, Second } order;
 
-  Order order;
-  DSP::IIR::OnePole onePole;  //first-order
-  DSP::IIR::Biquad biquad;    //second-order
+  DSP::IIR::DCRemoval dcRemoval;
+  DSP::IIR::OnePole onePole;
+  DSP::IIR::Biquad biquad;
 };
 
 struct Stream {
@@ -54,7 +58,9 @@ struct Stream {
 
   auto setFrequency(double inputFrequency, maybe<double> outputFrequency = nothing) -> void;
 
-  auto addFilter(Filter::Order order, Filter::Type type, double cutoffFrequency, uint passes = 1) -> void;
+  auto addDCRemovalFilter() -> void;
+  auto addLowPassFilter(double cutoffFrequency, Filter::Order order, uint passes = 1) -> void;
+  auto addHighPassFilter(double cutoffFrequency, Filter::Order order, uint passes = 1) -> void;
 
   auto pending() const -> bool;
   auto read(double samples[]) -> uint;
@@ -68,6 +74,7 @@ struct Stream {
 private:
   struct Channel {
     vector<Filter> filters;
+    vector<DSP::IIR::Biquad> nyquist;
     DSP::Resampler::Cubic resampler;
   };
   vector<Channel> channels;
@@ -80,3 +87,5 @@ private:
 extern Audio audio;
 
 }
+
+#undef double

bsnes/emulator/audio/stream.cpp

@@ -0,0 +1,106 @@
+auto Stream::reset(uint channelCount, double inputFrequency, double outputFrequency) -> void {
+  channels.reset();
+  channels.resize(channelCount);
+
+  for(auto& channel : channels) {
+    channel.filters.reset();
+  }
+
+  setFrequency(inputFrequency, outputFrequency);
+}
+
+auto Stream::setFrequency(double inputFrequency, maybe<double> outputFrequency) -> void {
+  this->inputFrequency = inputFrequency;
+  if(outputFrequency) this->outputFrequency = outputFrequency();
+
+  for(auto& channel : channels) {
+    channel.nyquist.reset();
+    channel.resampler.reset(this->inputFrequency, this->outputFrequency);
+  }
+
+  if(this->inputFrequency >= this->outputFrequency * 2) {
+    //add a low-pass filter to prevent aliasing during resampling
+    double cutoffFrequency = min(25000.0, this->outputFrequency / 2.0 - 2000.0);
+    for(auto& channel : channels) {
+      uint passes = 3;
+      for(uint pass : range(passes)) {
+        DSP::IIR::Biquad filter;
+        double q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
+        filter.reset(DSP::IIR::Biquad::Type::LowPass, cutoffFrequency, this->inputFrequency, q);
+        channel.nyquist.append(filter);
+      }
+    }
+  }
+}
+
+auto Stream::addDCRemovalFilter() -> void {
+  return;  //todo: test to ensure this is desirable before enabling
+  for(auto& channel : channels) {
+    Filter filter{Filter::Mode::DCRemoval, Filter::Type::None, Filter::Order::None};
+    channel.filters.append(filter);
+  }
+}
+
+auto Stream::addLowPassFilter(double cutoffFrequency, Filter::Order order, uint passes) -> void {
+  for(auto& channel : channels) {
+    for(uint pass : range(passes)) {
+      if(order == Filter::Order::First) {
+        Filter filter{Filter::Mode::OnePole, Filter::Type::LowPass, Filter::Order::First};
+        filter.onePole.reset(DSP::IIR::OnePole::Type::LowPass, cutoffFrequency, inputFrequency);
+        channel.filters.append(filter);
+      }
+      if(order == Filter::Order::Second) {
+        Filter filter{Filter::Mode::Biquad, Filter::Type::LowPass, Filter::Order::Second};
+        double q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
+        filter.biquad.reset(DSP::IIR::Biquad::Type::LowPass, cutoffFrequency, inputFrequency, q);
+        channel.filters.append(filter);
+      }
+    }
+  }
+}
+
+auto Stream::addHighPassFilter(double cutoffFrequency, Filter::Order order, uint passes) -> void {
+  for(auto& channel : channels) {
+    for(uint pass : range(passes)) {
+      if(order == Filter::Order::First) {
+        Filter filter{Filter::Mode::OnePole, Filter::Type::HighPass, Filter::Order::First};
+        filter.onePole.reset(DSP::IIR::OnePole::Type::HighPass, cutoffFrequency, inputFrequency);
+        channel.filters.append(filter);
+      }
+      if(order == Filter::Order::Second) {
+        Filter filter{Filter::Mode::Biquad, Filter::Type::HighPass, Filter::Order::Second};
+        double q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
+        filter.biquad.reset(DSP::IIR::Biquad::Type::HighPass, cutoffFrequency, inputFrequency, q);
+        channel.filters.append(filter);
+      }
+    }
+  }
+}
+
+auto Stream::pending() const -> bool {
+  return channels && channels[0].resampler.pending();
+}
+
+auto Stream::read(double samples[]) -> uint {
+  for(uint c : range(channels.size())) samples[c] = channels[c].resampler.read();
+  return channels.size();
+}
+
+auto Stream::write(const double samples[]) -> void {
+  for(auto c : range(channels.size())) {
+    double sample = samples[c] + 1e-25;  //constant offset used to suppress denormals
+    for(auto& filter : channels[c].filters) {
+      switch(filter.mode) {
+      case Filter::Mode::DCRemoval: sample = filter.dcRemoval.process(sample); break;
+      case Filter::Mode::OnePole: sample = filter.onePole.process(sample); break;
+      case Filter::Mode::Biquad: sample = filter.biquad.process(sample); break;
+      }
+    }
+    for(auto& filter : channels[c].nyquist) {
+      sample = filter.process(sample);
+    }
+    channels[c].resampler.write(sample);
+  }
+
+  audio.process();
+}

bsnes/emulator/cheat.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+namespace Emulator {
+
+struct Cheat {
+  struct Code {
+    auto operator==(const Code& code) const -> bool {
+      if(address != code.address) return false;
+      if(data != code.data) return false;
+      if((bool)compare != (bool)code.compare) return false;
+      if(compare && code.compare && compare() != code.compare()) return false;
+      return true;
+    }
+
+    uint address;
+    uint data;
+    maybe<uint> compare;
+    bool enable;
+    uint restore;
+  };
+
+  explicit operator bool() const {
+    return codes.size() > 0;
+  }
+
+  auto reset() -> void {
+    codes.reset();
+  }
+
+  auto append(uint address, uint data, maybe<uint> compare = {}) -> void {
+    codes.append({address, data, compare});
+  }
+
+  auto assign(const vector<string>& list) -> void {
+    reset();
+    for(auto& entry : list) {
+      for(auto code : entry.split("+")) {
+        auto part = code.transform("=?", "//").split("/");
+        if(part.size() == 2) append(part[0].hex(), part[1].hex());
+        if(part.size() == 3) append(part[0].hex(), part[2].hex(), part[1].hex());
+      }
+    }
+  }
+
+  auto find(uint address, uint compare) -> maybe<uint> {
+    for(auto& code : codes) {
+      if(code.address == address && (!code.compare || code.compare() == compare)) {
+        return code.data;
+      }
+    }
+    return nothing;
+  }
+
+  vector<Code> codes;
+};
+
+}

bsnes/emulator/emulator.cpp

@@ -1,4 +1,5 @@
 #include <emulator/emulator.hpp>
+#include <emulator/audio/audio.cpp>
 
 namespace Emulator {
 

bsnes/emulator/emulator.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <nall/platform.hpp>
+#include <nall/adaptive-array.hpp>
+#include <nall/any.hpp>
+#include <nall/chrono.hpp>
+#include <nall/dl.hpp>
+#include <nall/endian.hpp>
+#include <nall/image.hpp>
+#include <nall/literals.hpp>
+#include <nall/random.hpp>
+#include <nall/serializer.hpp>
+#include <nall/shared-pointer.hpp>
+#include <nall/string.hpp>
+#include <nall/traits.hpp>
+#include <nall/unique-pointer.hpp>
+#include <nall/vector.hpp>
+#include <nall/vfs.hpp>
+#include <nall/hash/crc32.hpp>
+#include <nall/hash/sha256.hpp>
+using namespace nall;
+
+#include <libco/libco.h>
+
+#include <emulator/types.hpp>
+#include <emulator/memory/readable.hpp>
+#include <emulator/memory/writable.hpp>
+#include <emulator/audio/audio.hpp>
+
+namespace Emulator {
+  static const string Name    = "bsnes";
+  static const string Version = "110";
+  static const string Author  = "byuu";
+  static const string License = "GPLv3";
+  static const string Website = "https://byuu.org";
+
+  //incremented only when serialization format changes
+  static const string SerializerVersion = "110";
+
+  namespace Constants {
+    namespace Colorburst {
+      static constexpr double NTSC = 315.0 / 88.0 * 1'000'000.0;
+      static constexpr double PAL  = 283.75 * 15'625.0 + 25.0;
+    }
+  }
+
+  //nall/vfs shorthand constants for open(), load()
+  namespace File {
+    static const auto Read  = vfs::file::mode::read;
+    static const auto Write = vfs::file::mode::write;
+    static const auto Optional = false;
+    static const auto Required = true;
+  };
+}
+
+#include "platform.hpp"
+#include "interface.hpp"
+#include "game.hpp"

bsnes/emulator/game.hpp

@@ -0,0 +1,112 @@
+#pragma once
+
+namespace Emulator {
+
+struct Game {
+  struct Memory;
+  struct Oscillator;
+
+  inline auto load(string_view) -> void;
+  inline auto memory(Markup::Node) -> maybe<Memory>;
+  inline auto oscillator(natural = 0) -> maybe<Oscillator>;
+
+  struct Memory {
+    Memory() = default;
+    inline Memory(Markup::Node);
+    explicit operator bool() const { return (bool)type; }
+    inline auto name() const -> string;
+
+    string type;
+    natural size;
+    string content;
+    string manufacturer;
+    string architecture;
+    string identifier;
+    boolean nonVolatile;
+  };
+
+  struct Oscillator {
+    Oscillator() = default;
+    inline Oscillator(Markup::Node);
+    explicit operator bool() const { return frequency; }
+
+    natural frequency;
+  };
+
+  Markup::Node document;
+  string sha256;
+  string label;
+  string name;
+  string title;
+  string region;
+  string revision;
+  string board;
+  vector<Memory> memoryList;
+  vector<Oscillator> oscillatorList;
+};
+
+auto Game::load(string_view text) -> void {
+  document = BML::unserialize(text);
+
+  sha256 = document["game/sha256"].text();
+  label = document["game/label"].text();
+  name = document["game/name"].text();
+  title = document["game/title"].text();
+  region = document["game/region"].text();
+  revision = document["game/revision"].text();
+  board = document["game/board"].text();
+
+  for(auto node : document.find("game/board/memory")) {
+    memoryList.append(Memory{node});
+  }
+
+  for(auto node : document.find("game/board/oscillator")) {
+    oscillatorList.append(Oscillator{node});
+  }
+}
+
+auto Game::memory(Markup::Node node) -> maybe<Memory> {
+  if(!node) return nothing;
+  for(auto& memory : memoryList) {
+    auto type = node["type"].text();
+    auto size = node["size"].natural();
+    auto content = node["content"].text();
+    auto manufacturer = node["manufacturer"].text();
+    auto architecture = node["architecture"].text();
+    auto identifier = node["identifier"].text();
+    if(type && type != memory.type) continue;
+    if(size && size != memory.size) continue;
+    if(content && content != memory.content) continue;
+    if(manufacturer && manufacturer != memory.manufacturer) continue;
+    if(architecture && architecture != memory.architecture) continue;
+    if(identifier && identifier != memory.identifier) continue;
+    return memory;
+  }
+  return nothing;
+}
+
+auto Game::oscillator(natural index) -> maybe<Oscillator> {
+  if(index < oscillatorList.size()) return oscillatorList[index];
+  return nothing;
+}
+
+Game::Memory::Memory(Markup::Node node) {
+  type = node["type"].text();
+  size = node["size"].natural();
+  content = node["content"].text();
+  manufacturer = node["manufacturer"].text();
+  architecture = node["architecture"].text();
+  identifier = node["identifier"].text();
+  nonVolatile = !(bool)node["volatile"];
+}
+
+auto Game::Memory::name() const -> string {
+  if(architecture) return string{architecture, ".", content, ".", type}.downcase();
+  return string{content, ".", type}.downcase();
+}
+
+Game::Oscillator::Oscillator(Markup::Node node) {
+  frequency = node["frequency"].natural();
+}
+
+}

bsnes/emulator/interface.hpp

@@ -0,0 +1,106 @@
+#pragma once
+
+namespace Emulator {
+
+struct Interface {
+  struct Information {
+    string manufacturer;
+    string name;
+    string extension;
+    bool resettable = false;
+  };
+
+  struct Display {
+    struct Type { enum : uint {
+      CRT,
+      LCD,
+    };};
+    uint id = 0;
+    string name;
+    uint type = 0;
+    uint colors = 0;
+    uint width = 0;
+    uint height = 0;
+    uint internalWidth = 0;
+    uint internalHeight = 0;
+    double aspectCorrection = 0;
+  };
+
+  struct Port {
+    uint id;
+    string name;
+  };
+
+  struct Device {
+    uint id;
+    string name;
+  };
+
+  struct Input {
+    struct Type { enum : uint {
+      Hat,
+      Button,
+      Trigger,
+      Control,
+      Axis,
+      Rumble,
+    };};
+
+    uint type;
+    string name;
+  };
+
+  //information
+  virtual auto information() -> Information { return {}; }
+
+  virtual auto display() -> Display { return {}; }
+  virtual auto color(uint32 color) -> uint64 { return 0; }
+
+  //game interface
+  virtual auto loaded() -> bool { return false; }
+  virtual auto hashes() -> vector<string> { return {}; }
+  virtual auto manifests() -> vector<string> { return {}; }
+  virtual auto titles() -> vector<string> { return {}; }
+  virtual auto title() -> string { return {}; }
+  virtual auto load() -> bool { return false; }
+  virtual auto save() -> void {}
+  virtual auto unload() -> void {}
+
+  //system interface
+  virtual auto ports() -> vector<Port> { return {}; }
+  virtual auto devices(uint port) -> vector<Device> { return {}; }
+  virtual auto inputs(uint device) -> vector<Input> { return {}; }
+  virtual auto connected(uint port) -> uint { return 0; }
+  virtual auto connect(uint port, uint device) -> void {}
+  virtual auto power() -> void {}
+  virtual auto reset() -> void {}
+  virtual auto run() -> void {}
+
+  //time functions
+  virtual auto rtc() -> bool { return false; }
+  virtual auto synchronize(uint64 timestamp = 0) -> void {}
+
+  //state functions
+  virtual auto serialize() -> serializer { return {}; }
+  virtual auto unserialize(serializer&) -> bool { return false; }
+
+  //cheat functions
+  virtual auto read(uint24 address) -> uint8 { return 0; }
+  virtual auto cheats(const vector<string>& = {}) -> void {}
+
+  //configuration
+  virtual auto configuration() -> string { return {}; }
+  virtual auto configuration(string name) -> string { return {}; }
+  virtual auto configure(string configuration = "") -> bool { return false; }
+  virtual auto configure(string name, string value) -> bool { return false; }
+
+  //settings
+  virtual auto cap(const string& name) -> bool { return false; }
+  virtual auto get(const string& name) -> any { return {}; }
+  virtual auto set(const string& name, const any& value) -> bool { return false; }
+
+  virtual auto frameSkip() -> uint { return 0; }
+  virtual auto setFrameSkip(uint frameSkip) -> void {}
+};
+
+}

bsnes/emulator/memory/memory.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+namespace Emulator::Memory {
+
+inline auto mirror(uint address, uint size) -> uint {
+  if(size == 0) return 0;
+  uint base = 0;
+  uint mask = 1 << 31;
+  while(address >= size) {
+    while(!(address & mask)) mask >>= 1;
+    address -= mask;
+    if(size > mask) {
+      size -= mask;
+      base += mask;
+    }
+    mask >>= 1;
+  }
+  return base + address;
+}
+
+inline auto reduce(uint address, uint mask) -> uint {
+  while(mask) {
+    uint bits = (mask & -mask) - 1;
+    address = address >> 1 & ~bits | address & bits;
+    mask = (mask & mask - 1) >> 1;
+  }
+  return address;
+}
+
+}

bsnes/emulator/memory/readable.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <emulator/memory/memory.hpp>
+
+namespace Emulator::Memory {
+
+template<typename T>
+struct Readable {
+  ~Readable() { reset(); }
+
+  inline auto reset() -> void {
+    delete[] self.data;
+    self.data = nullptr;
+    self.size = 0;
+    self.mask = 0;
+  }
+
+  inline auto allocate(uint size, T fill = ~0ull) -> void {
+    if(!size) return reset();
+    delete[] self.data;
+    self.size = size;
+    self.mask = bit::round(self.size) - 1;
+    self.data = new T[self.mask + 1];
+    memory::fill<T>(self.data, self.mask + 1, fill);
+  }
+
+  inline auto load(shared_pointer<vfs::file> fp) -> void {
+    fp->read(self.data, min(fp->size(), self.size * sizeof(T)));
+    for(uint address = self.size; address <= self.mask; address++) {
+      self.data[address] = self.data[mirror(address, self.size)];
+    }
+  }
+
+  inline auto save(shared_pointer<vfs::file> fp) -> void {
+    fp->write(self.data, self.size * sizeof(T));
+  }
+
+  explicit operator bool() const { return (bool)self.data; }
+  inline auto data() const -> const T* { return self.data; }
+  inline auto size() const -> uint { return self.size; }
+  inline auto mask() const -> uint { return self.mask; }
+
+  inline auto operator[](uint address) const -> T { return self.data[address & self.mask]; }
+  inline auto read(uint address) const -> T { return self.data[address & self.mask]; }
+  inline auto write(uint address, T data) const -> void {}
+
+  auto serialize(serializer& s) -> void {
+    const uint size = self.size;
+    s.integer(self.size);
+    s.integer(self.mask);
+    if(self.size != size) allocate(self.size);
+    s.array(self.data, self.size);
+  }
+
+private:
+  struct {
+    T* data = nullptr;
+    uint size = 0;
+    uint mask = 0;
+  } self;
+};
+
+}

bsnes/emulator/memory/writable.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <emulator/memory/memory.hpp>
+
+namespace Emulator::Memory {
+
+template<typename T>
+struct Writable {
+  ~Writable() { reset(); }
+
+  inline auto reset() -> void {
+    delete[] self.data;
+    self.data = nullptr;
+    self.size = 0;
+    self.mask = 0;
+  }
+
+  inline auto allocate(uint size, T fill = ~0ull) -> void {
+    if(!size) return reset();
+    delete[] self.data;
+    self.size = size;
+    self.mask = bit::round(self.size) - 1;
+    self.data = new T[self.mask + 1];
+    memory::fill<T>(self.data, self.mask + 1, fill);
+  }
+
+  inline auto load(shared_pointer<vfs::file> fp) -> void {
+    fp->read(self.data, min(fp->size(), self.size * sizeof(T)));
+    for(uint address = self.size; address <= self.mask; address++) {
+      self.data[address] = self.data[mirror(address, self.size)];
+    }
+  }
+
+  inline auto save(shared_pointer<vfs::file> fp) -> void {
+    fp->write(self.data, self.size * sizeof(T));
+  }
+
+  explicit operator bool() const { return (bool)self.data; }
+  inline auto data() -> T* { return self.data; }
+  inline auto data() const -> const T* { return self.data; }
+  inline auto size() const -> uint { return self.size; }
+  inline auto mask() const -> uint { return self.mask; }
+
+  inline auto operator[](uint address) -> T& { return self.data[address & self.mask]; }
+  inline auto operator[](uint address) const -> T { return self.data[address & self.mask]; }
+  inline auto read(uint address) const -> T { return self.data[address & self.mask]; }
+  inline auto write(uint address, T data) -> void { self.data[address & self.mask] = data; }
+
+  auto serialize(serializer& s) -> void {
+    const uint size = self.size;
+    s.integer(self.size);
+    s.integer(self.mask);
+    if(self.size != size) allocate(self.size);
+    s.array(self.data, self.size);
+  }
+
+private:
+  struct {
+    T* data = nullptr;
+    uint size = 0;
+    uint mask = 0;
+  } self;
+};
+
+}

bsnes/emulator/platform.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+namespace Emulator {
+
+struct Platform {
+  struct Load {
+    Load() = default;
+    Load(uint pathID, string option = "") : valid(true), pathID(pathID), option(option) {}
+    explicit operator bool() const { return valid; }
+
+    bool valid = false;
+    uint pathID = 0;
+    string option;
+  };
+
+  virtual auto path(uint id) -> string { return ""; }
+  virtual auto open(uint id, string name, vfs::file::mode mode, bool required = false) -> shared_pointer<vfs::file> { return {}; }
+  virtual auto load(uint id, string name, string type, vector<string> options = {}) -> Load { return {}; }
+  virtual auto videoFrame(const uint16* data, uint pitch, uint width, uint height, uint scale) -> void {}
+  virtual auto audioFrame(const float* samples, uint channels) -> void {}
+  virtual auto inputPoll(uint port, uint device, uint input) -> int16 { return 0; }
+  virtual auto inputRumble(uint port, uint device, uint input, bool enable) -> void {}
+  virtual auto dipSettings(Markup::Node node) -> uint { return 0; }
+  virtual auto notify(string text) -> void {}
+};
+
+extern Platform* platform;
+
+}

bsnes/emulator/random.hpp

@@ -65,10 +65,10 @@ struct Random {
     if((random() & 1) == 0) hivalue = ~lovalue;
 
     for(uint32 address : range(size)) {
-      uint8 value = address.bit(lobit) ? lovalue : hivalue;
-      if(address.bit(hibit)) value = ~value;
-      if((random() &  511) == 0) value.bit(random() & 7) ^= 1;
-      if((random() & 2047) == 0) value.bit(random() & 7) ^= 1;
+      uint8 value = (address & 1ull << lobit) ? lovalue : hivalue;
+      if((address & 1ull << hibit)) value = ~value;
+      if((random() &  511) == 0) value ^= 1 << (random() & 7);
+      if((random() & 2047) == 0) value ^= 1 << (random() & 7);
       data[address] = value;
     }
   }

bsnes/emulator/types.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+using  int1 = nall::Integer< 1>;
+using  int2 = nall::Integer< 2>;
+using  int3 = nall::Integer< 3>;
+using  int4 = nall::Integer< 4>;
+using  int5 = nall::Integer< 5>;
+using  int6 = nall::Integer< 6>;
+using  int7 = nall::Integer< 7>;
+using  int8 = int8_t;
+using  int9 = nall::Integer< 9>;
+using int10 = nall::Integer<10>;
+using int11 = nall::Integer<11>;
+using int12 = nall::Integer<12>;
+using int13 = nall::Integer<13>;
+using int14 = nall::Integer<14>;
+using int15 = nall::Integer<15>;
+using int16 = int16_t;
+using int17 = nall::Integer<17>;
+using int18 = nall::Integer<18>;
+using int19 = nall::Integer<19>;
+using int20 = nall::Integer<20>;
+using int21 = nall::Integer<21>;
+using int22 = nall::Integer<22>;
+using int23 = nall::Integer<23>;
+using int24 = nall::Integer<24>;
+using int25 = nall::Integer<25>;
+using int26 = nall::Integer<26>;
+using int27 = nall::Integer<27>;
+using int28 = nall::Integer<28>;
+using int29 = nall::Integer<29>;
+using int30 = nall::Integer<30>;
+using int31 = nall::Integer<31>;
+using int32 = int32_t;
+using int48 = nall::Integer<48>;  //Cx4
+using int64 = int64_t;
+
+using  uint1 = nall::Natural< 1>;
+using  uint2 = nall::Natural< 2>;
+using  uint3 = nall::Natural< 3>;
+using  uint4 = nall::Natural< 4>;
+using  uint5 = nall::Natural< 5>;
+using  uint6 = nall::Natural< 6>;
+using  uint7 = nall::Natural< 7>;
+using  uint8 = uint8_t;
+using  uint9 = nall::Natural< 9>;
+using uint10 = nall::Natural<10>;
+using uint11 = nall::Natural<11>;
+using uint12 = nall::Natural<12>;
+using uint13 = nall::Natural<13>;
+using uint14 = nall::Natural<14>;
+using uint15 = nall::Natural<15>;
+using uint16 = uint16_t;
+using uint17 = nall::Natural<17>;
+using uint18 = nall::Natural<18>;
+using uint19 = nall::Natural<19>;
+using uint20 = nall::Natural<20>;
+using uint21 = nall::Natural<21>;
+using uint22 = nall::Natural<22>;
+using uint23 = nall::Natural<23>;
+using uint24 = nall::Natural<24>;
+using uint25 = nall::Natural<25>;
+using uint26 = nall::Natural<26>;
+using uint27 = nall::Natural<27>;
+using uint28 = nall::Natural<28>;
+using uint29 = nall::Natural<29>;
+using uint30 = nall::Natural<30>;
+using uint31 = nall::Natural<31>;
+using uint32 = uint32_t;
+using uint40 = nall::Natural<40>;  //SA1
+using uint48 = nall::Natural<48>;  //Cx4
+using uint64 = uint64_t;

bsnes/filter/2xsai.cpp

@@ -0,0 +1,25 @@
+namespace Filter::_2xSaI {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+uint32_t temp[512 * 480];
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t*)(((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * width;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  _2xSaI32((unsigned char*)temp, width * sizeof(uint32_t), 0, (unsigned char*)output, outpitch, width, height);
+}
+
+}

bsnes/filter/filter.cpp

@@ -0,0 +1,25 @@
+#include <emulator/emulator.hpp>
+
+#undef register
+#define register
+#include "sai/sai.cpp"
+
+uint32_t* colortable;
+#include "snes_ntsc/snes_ntsc.h"
+#include "snes_ntsc/snes_ntsc.c"
+
+#include "none.cpp"
+#include "scanlines-light.cpp"
+#include "scanlines-dark.cpp"
+#include "scanlines-black.cpp"
+#include "pixellate2x.cpp"
+#include "scale2x.cpp"
+#include "2xsai.cpp"
+#include "super-2xsai.cpp"
+#include "super-eagle.cpp"
+#include "lq2x.cpp"
+#include "hq2x.cpp"
+#include "ntsc-rf.cpp"
+#include "ntsc-composite.cpp"
+#include "ntsc-svideo.cpp"
+#include "ntsc-rgb.cpp"

bsnes/filter/filter.hpp

@@ -0,0 +1,129 @@
+#pragma once
+
+#include <emulator/emulator.hpp>
+
+namespace Filter {
+  using Size = auto (*)(uint& width, uint& height) -> void;
+  using Render = auto (*)(uint32_t* palette, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height) -> void;
+}
+
+namespace Filter::None {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::ScanlinesLight {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::ScanlinesDark {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::ScanlinesBlack {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::Pixellate2x {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::Scale2x {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::_2xSaI {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::Super2xSaI {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::SuperEagle {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::LQ2x {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::HQ2x {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::NTSC_RF {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::NTSC_Composite {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::NTSC_SVideo {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}
+
+namespace Filter::NTSC_RGB {
+  auto size(uint& width, uint& height) -> void;
+  auto render(
+    uint32_t* colortable, uint32_t* output, uint outpitch,
+    const uint16_t* input, uint pitch, uint width, uint height
+  ) -> void;
+}

bsnes/filter/hq2x.cpp

@@ -0,0 +1,200 @@
+namespace Filter::HQ2x {
+
+enum {
+  diff_offset = (0x440 << 21) + (0x207 << 11) + 0x407,
+  diff_mask   = (0x380 << 21) + (0x1f0 << 11) + 0x3f0,
+};
+
+uint32_t *yuvTable;
+uint8_t rotate[256];
+
+const uint8_t hqTable[256] = {
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 15, 12, 5,  3, 17, 13,
+  4, 4, 6, 18, 4, 4, 6, 18, 5,  3, 12, 12, 5,  3,  1, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 17, 13, 5,  3, 16, 14,
+  4, 4, 6, 18, 4, 4, 6, 18, 5,  3, 16, 12, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5, 19, 12, 12, 5, 19, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5, 19,  1, 12, 5, 19,  1, 14,
+  4, 4, 6,  2, 4, 4, 6, 18, 5,  3, 16, 12, 5, 19,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 15, 12, 5,  3, 17, 13,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 17, 13, 5,  3, 16, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 13, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 13,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3,  1, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3,  1, 12, 5,  3,  1, 14,
+};
+
+static void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  yuvTable = new uint32_t[32768];
+
+  for(unsigned i = 0; i < 32768; i++) {
+    uint8_t R = (i >>  0) & 31;
+    uint8_t G = (i >>  5) & 31;
+    uint8_t B = (i >> 10) & 31;
+
+    //bgr555->bgr888
+    double r = (R << 3) | (R >> 2);
+    double g = (G << 3) | (G >> 2);
+    double b = (B << 3) | (B >> 2);
+
+    //bgr888->yuv
+    double y = (r + g + b) * (0.25f * (63.5f / 48.0f));
+    double u = ((r - b) * 0.25f + 128.0f) * (7.5f / 7.0f);
+    double v = ((g * 2.0f - r - b) * 0.125f + 128.0f) * (7.5f / 6.0f);
+
+    yuvTable[i] = ((unsigned)y << 21) + ((unsigned)u << 11) + ((unsigned)v);
+  }
+
+  //counter-clockwise rotation table; one revolution:
+  //123    369  12346789
+  //4.6 -> 2.8  =
+  //789    147  36928147
+  for(unsigned n = 0; n < 256; n++) {
+    rotate[n] = ((n >> 2) & 0x11) | ((n << 2) & 0x88)
+              | ((n & 0x01) << 5) | ((n & 0x08) << 3)
+              | ((n & 0x10) >> 3) | ((n & 0x80) >> 5);
+  }
+}
+
+static void terminate() {
+  delete[] yuvTable;
+}
+
+static bool same(uint16_t x, uint16_t y) {
+  return !((yuvTable[x] - yuvTable[y] + diff_offset) & diff_mask);
+}
+
+static bool diff(uint32_t x, uint16_t y) {
+  return ((x - yuvTable[y]) & diff_mask);
+}
+
+static void grow(uint32_t &n) { n |= n << 16; n &= 0x03e07c1f; }
+static uint16_t pack(uint32_t n) { n &= 0x03e07c1f; return n | (n >> 16); }
+
+static uint16_t blend1(uint32_t A, uint32_t B) {
+  grow(A); grow(B);
+  return pack((A * 3 + B) >> 2);
+}
+
+static uint16_t blend2(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 2 + B + C) >> 2);
+}
+
+static uint16_t blend3(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 5 + B * 2 + C) >> 3);
+}
+
+static uint16_t blend4(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 6 + B + C) >> 3);
+}
+
+static uint16_t blend5(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 2 + (B + C) * 3) >> 3);
+}
+
+static uint16_t blend6(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 14 + B + C) >> 4);
+}
+
+static uint16_t blend(unsigned rule, uint16_t E, uint16_t A, uint16_t B, uint16_t D, uint16_t F, uint16_t H) {
+  switch(rule) { default:
+    case  0: return E;
+    case  1: return blend1(E, A);
+    case  2: return blend1(E, D);
+    case  3: return blend1(E, B);
+    case  4: return blend2(E, D, B);
+    case  5: return blend2(E, A, B);
+    case  6: return blend2(E, A, D);
+    case  7: return blend3(E, B, D);
+    case  8: return blend3(E, D, B);
+    case  9: return blend4(E, D, B);
+    case 10: return blend5(E, D, B);
+    case 11: return blend6(E, D, B);
+    case 12: return same(B, D) ? blend2(E, D, B) : E;
+    case 13: return same(B, D) ? blend5(E, D, B) : E;
+    case 14: return same(B, D) ? blend6(E, D, B) : E;
+    case 15: return same(B, D) ? blend2(E, D, B) : blend1(E, A);
+    case 16: return same(B, D) ? blend4(E, D, B) : blend1(E, A);
+    case 17: return same(B, D) ? blend5(E, D, B) : blend1(E, A);
+    case 18: return same(B, F) ? blend3(E, B, D) : blend1(E, D);
+    case 19: return same(D, H) ? blend3(E, D, B) : blend1(E, B);
+  }
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(uint y = 0; y < height; y++) {
+    const uint16_t* in = input + y * pitch;
+    uint32_t* out0 = output + y * outpitch * 2;
+    uint32_t* out1 = output + y * outpitch * 2 + outpitch;
+
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    in++;
+    *out0++ = 0; *out0++ = 0;
+    *out1++ = 0; *out1++ = 0;
+
+    for(unsigned x = 1; x < width - 1; x++) {
+      uint16_t A = *(in - prevline - 1);
+      uint16_t B = *(in - prevline + 0);
+      uint16_t C = *(in - prevline + 1);
+      uint16_t D = *(in - 1);
+      uint16_t E = *(in + 0);
+      uint16_t F = *(in + 1);
+      uint16_t G = *(in + nextline - 1);
+      uint16_t H = *(in + nextline + 0);
+      uint16_t I = *(in + nextline + 1);
+      uint32_t e = yuvTable[E] + diff_offset;
+
+      uint8_t pattern;
+      pattern  = diff(e, A) << 0;
+      pattern |= diff(e, B) << 1;
+      pattern |= diff(e, C) << 2;
+      pattern |= diff(e, D) << 3;
+      pattern |= diff(e, F) << 4;
+      pattern |= diff(e, G) << 5;
+      pattern |= diff(e, H) << 6;
+      pattern |= diff(e, I) << 7;
+
+      *(out0 + 0) = colortable[blend(hqTable[pattern], E, A, B, D, F, H)]; pattern = rotate[pattern];
+      *(out0 + 1) = colortable[blend(hqTable[pattern], E, C, F, B, H, D)]; pattern = rotate[pattern];
+      *(out1 + 1) = colortable[blend(hqTable[pattern], E, I, H, F, D, B)]; pattern = rotate[pattern];
+      *(out1 + 0) = colortable[blend(hqTable[pattern], E, G, D, H, B, F)];
+
+      in++;
+      out0 += 2;
+      out1 += 2;
+    }
+
+    in++;
+    *out0++ = 0; *out0++ = 0;
+    *out1++ = 0; *out1++ = 0;
+  }
+}
+
+}

bsnes/filter/lq2x.cpp

@@ -0,0 +1,46 @@
+namespace Filter::LQ2x {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(uint y = 0; y < height; y++) {
+    const uint16_t* in = input + y * pitch;
+    uint32_t* out0 = output + y * outpitch * 2;
+    uint32_t* out1 = output + y * outpitch * 2 + outpitch;
+
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    for(uint x = 0; x < width; x++) {
+      uint16_t A = *(in - prevline);
+      uint16_t B = (x > 0) ? *(in - 1) : *in;
+      uint16_t C = *in;
+      uint16_t D = (x < width - 1) ? *(in + 1) : *in;
+      uint16_t E = *(in++ + nextline);
+      uint32_t c = colortable[C];
+
+      if(A != E && B != D) {
+        *out0++ = (A == B ? colortable[C + A - ((C ^ A) & 0x0421) >> 1] : c);
+        *out0++ = (A == D ? colortable[C + A - ((C ^ A) & 0x0421) >> 1] : c);
+        *out1++ = (E == B ? colortable[C + E - ((C ^ E) & 0x0421) >> 1] : c);
+        *out1++ = (E == D ? colortable[C + E - ((C ^ E) & 0x0421) >> 1] : c);
+      } else {
+        *out0++ = c;
+        *out0++ = c;
+        *out1++ = c;
+        *out1++ = c;
+      }
+    }
+  }
+}
+
+}

bsnes/filter/none.cpp

@@ -0,0 +1,24 @@
+namespace Filter::None {
+
+auto size(uint& width, uint& height) -> void {
+  width  = width;
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(uint y = 0; y < height; y++) {
+    const uint16_t* in = input + y * pitch;
+    uint32_t* out = output + y * outpitch;
+    for(uint x = 0; x < width; x++) {
+      *out++ = colortable[*in++];
+    }
+  }
+}
+
+}

bsnes/filter/ntsc-composite.cpp

@@ -0,0 +1,50 @@
+namespace Filter::NTSC_Composite {
+
+struct snes_ntsc_t *ntsc;
+snes_ntsc_setup_t setup;
+int burst;
+int burst_toggle;
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  setup = snes_ntsc_composite;
+  setup.merge_fields = 1;
+  snes_ntsc_init(ntsc, &setup);
+
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);
+}
+
+void terminate() {
+  if(ntsc) free(ntsc);
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = SNES_NTSC_OUT_WIDTH(256);
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable_, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+  colortable = colortable_;
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+}

bsnes/filter/ntsc-rf.cpp

@@ -0,0 +1,50 @@
+namespace Filter::NTSC_RF {
+
+struct snes_ntsc_t *ntsc;
+snes_ntsc_setup_t setup;
+int burst;
+int burst_toggle;
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  setup = snes_ntsc_composite;
+  setup.merge_fields = 0;
+  snes_ntsc_init(ntsc, &setup);
+
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);
+}
+
+void terminate() {
+  if(ntsc) free(ntsc);
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = SNES_NTSC_OUT_WIDTH(256);
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable_, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+  colortable = colortable_;
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+}

bsnes/filter/ntsc-rgb.cpp

@@ -0,0 +1,50 @@
+namespace Filter::NTSC_RGB {
+
+struct snes_ntsc_t *ntsc;
+snes_ntsc_setup_t setup;
+int burst;
+int burst_toggle;
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  setup = snes_ntsc_rgb;
+  setup.merge_fields = 1;
+  snes_ntsc_init(ntsc, &setup);
+
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);
+}
+
+void terminate() {
+  if(ntsc) free(ntsc);
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = SNES_NTSC_OUT_WIDTH(256);
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable_, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+  colortable = colortable_;
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+}

bsnes/filter/ntsc-svideo.cpp

@@ -0,0 +1,50 @@
+namespace Filter::NTSC_SVideo {
+
+struct snes_ntsc_t *ntsc;
+snes_ntsc_setup_t setup;
+int burst;
+int burst_toggle;
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  setup = snes_ntsc_svideo;
+  setup.merge_fields = 1;
+  snes_ntsc_init(ntsc, &setup);
+
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);
+}
+
+void terminate() {
+  if(ntsc) free(ntsc);
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = SNES_NTSC_OUT_WIDTH(256);
+  height = height;
+}
+
+auto render(
+  uint32_t* colortable_, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+  colortable = colortable_;
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+}

bsnes/filter/pixellate2x.cpp

@@ -0,0 +1,40 @@
+namespace Filter::Pixellate2x {
+
+auto size(uint& width, uint& height) -> void {
+  width  = (width  <= 256) ? width  * 2 : width;
+  height = (height <= 240) ? height * 2 : height;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch >>= 1;
+  outpitch >>= 2;
+
+  uint32_t *out0 = output;
+  uint32_t *out1 = output + outpitch;
+
+  for(unsigned y = 0; y < height; y++) {
+    for(unsigned x = 0; x < width; x++) {
+      uint32_t p = colortable[*input++];
+
+      *out0++ = p;
+      if(height <= 240) *out1++ = p;
+      if(width > 256) continue;
+
+      *out0++ = p;
+      if(height <= 240) *out1++ = p;
+    }
+
+    input += pitch - width;
+    if(height <= 240) {
+      out0 += outpitch + outpitch - 512;
+      out1 += outpitch + outpitch - 512;
+    } else {
+      out0 += outpitch - 512;
+    }
+  }
+}
+
+}

bsnes/filter/scale2x.cpp

@@ -0,0 +1,46 @@
+namespace Filter::Scale2x {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(uint y = 0; y < height; y++) {
+    const uint16_t* in = input + y * pitch;
+    uint32_t* out0 = output + y * outpitch * 2;
+    uint32_t* out1 = output + y * outpitch * 2 + outpitch;
+
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t A = *(in - prevline);
+      uint16_t B = (x > 0) ? *(in - 1) : *in;
+      uint16_t C = *in;
+      uint16_t D = (x < width - 1) ? *(in + 1) : *in;
+      uint16_t E = *(in++ + nextline);
+      uint32_t c = colortable[C];
+
+      if(A != E && B != D) {
+        *out0++ = (A == B ? colortable[A] : c);
+        *out0++ = (A == D ? colortable[A] : c);
+        *out1++ = (E == B ? colortable[E] : c);
+        *out1++ = (E == D ? colortable[E] : c);
+      } else {
+        *out0++ = c;
+        *out0++ = c;
+        *out1++ = c;
+        *out1++ = c;
+      }
+    }
+  }
+}
+
+}

bsnes/filter/scanlines-black.cpp

@@ -0,0 +1,28 @@
+namespace Filter::ScanlinesBlack {
+
+auto size(uint& width, uint& height) -> void {
+  width  = width;
+  height = height * 2;
+}
+
+auto render(
+  uint32_t* palette, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *in = input + y * pitch;
+    uint32_t *out0 = output + y * outpitch * 2;
+    uint32_t *out1 = output + y * outpitch * 2 + outpitch;
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t color = *in++;
+      *out0++ = palette[color];
+      *out1++ = 0;
+    }
+  }
+}
+
+}

bsnes/filter/scanlines-dark.cpp

@@ -0,0 +1,48 @@
+namespace Filter::ScanlinesDark {
+
+uint16_t adjust[32768];
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  for(unsigned i = 0; i < 32768; i++) {
+    uint8_t r = (i >> 10) & 31;
+    uint8_t g = (i >>  5) & 31;
+    uint8_t b = (i >>  0) & 31;
+    r *= 0.333;
+    g *= 0.333;
+    b *= 0.333;
+    adjust[i] = (r << 10) + (g << 5) + (b << 0);
+  }
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = width;
+  height = height * 2;
+}
+
+auto render(
+  uint32_t* palette, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *in = input + y * pitch;
+    uint32_t *out0 = output + y * outpitch * 2;
+    uint32_t *out1 = output + y * outpitch * 2 + outpitch;
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t color = *in++;
+      *out0++ = palette[color];
+      *out1++ = palette[adjust[color]];
+    }
+  }
+}
+
+}

bsnes/filter/scanlines-light.cpp

@@ -0,0 +1,48 @@
+namespace Filter::ScanlinesLight {
+
+uint16_t adjust[32768];
+
+void initialize() {
+  static bool initialized = false;
+  if(initialized == true) return;
+  initialized = true;
+
+  for(unsigned i = 0; i < 32768; i++) {
+    uint8_t r = (i >> 10) & 31;
+    uint8_t g = (i >>  5) & 31;
+    uint8_t b = (i >>  0) & 31;
+    r *= 0.666;
+    g *= 0.666;
+    b *= 0.666;
+    adjust[i] = (r << 10) + (g << 5) + (b << 0);
+  }
+}
+
+auto size(uint& width, uint& height) -> void {
+  width  = width;
+  height = height * 2;
+}
+
+auto render(
+  uint32_t* palette, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  initialize();
+
+  pitch    >>= 1;
+  outpitch >>= 2;
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *in = input + y * pitch;
+    uint32_t *out0 = output + y * outpitch * 2;
+    uint32_t *out1 = output + y * outpitch * 2 + outpitch;
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t color = *in++;
+      *out0++ = palette[color];
+      *out1++ = palette[adjust[color]];
+    }
+  }
+}
+
+}

bsnes/filter/snes_ntsc/snes_ntsc.c

@@ -0,0 +1,251 @@
+/* snes_ntsc 0.2.2. http://www.slack.net/~ant/ */
+
+#include "snes_ntsc.h"
+
+/* Copyright (C) 2006-2007 Shay Green. This module is free software; you
+can redistribute it and/or modify it under the terms of the GNU Lesser
+General Public License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version. This
+module is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details. You should have received a copy of the GNU Lesser General Public
+License along with this module; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
+
+snes_ntsc_setup_t const snes_ntsc_monochrome = { 0,-1, 0, 0,.2,  0,.2,-.2,-.2,-1,  1, 0, 0 };
+snes_ntsc_setup_t const snes_ntsc_composite  = { 0, 0, 0, 0, 0,  0, 0,  0,  0, 0,  1, 0, 0 };
+snes_ntsc_setup_t const snes_ntsc_svideo     = { 0, 0, 0, 0,.2,  0,.2, -1, -1, 0,  1, 0, 0 };
+snes_ntsc_setup_t const snes_ntsc_rgb        = { 0, 0, 0, 0,.2,  0,.7, -1, -1,-1,  1, 0, 0 };
+
+#define alignment_count 3
+#define burst_count     3
+#define rescale_in      8
+#define rescale_out     7
+
+#define artifacts_mid   1.0f
+#define fringing_mid    1.0f
+#define std_decoder_hue 0
+
+#define rgb_bits        7 /* half normal range to allow for doubled hires pixels */
+#define gamma_size      32
+
+#include "snes_ntsc_impl.h"
+
+/* 3 input pixels -> 8 composite samples */
+pixel_info_t const snes_ntsc_pixels [alignment_count] = {
+	{ PIXEL_OFFSET( -4, -9 ), { 1, 1, .6667f, 0 } },
+	{ PIXEL_OFFSET( -2, -7 ), {       .3333f, 1, 1, .3333f } },
+	{ PIXEL_OFFSET(  0, -5 ), {                  0, .6667f, 1, 1 } },
+};
+
+static void merge_kernel_fields( snes_ntsc_rgb_t* io )
+{
+	int n;
+	for ( n = burst_size; n; --n )
+	{
+		snes_ntsc_rgb_t p0 = io [burst_size * 0] + rgb_bias;
+		snes_ntsc_rgb_t p1 = io [burst_size * 1] + rgb_bias;
+		snes_ntsc_rgb_t p2 = io [burst_size * 2] + rgb_bias;
+		/* merge colors without losing precision */
+		io [burst_size * 0] =
+				((p0 + p1 - ((p0 ^ p1) & snes_ntsc_rgb_builder)) >> 1) - rgb_bias;
+		io [burst_size * 1] =
+				((p1 + p2 - ((p1 ^ p2) & snes_ntsc_rgb_builder)) >> 1) - rgb_bias;
+		io [burst_size * 2] =
+				((p2 + p0 - ((p2 ^ p0) & snes_ntsc_rgb_builder)) >> 1) - rgb_bias;
+		++io;
+	}
+}
+
+static void correct_errors( snes_ntsc_rgb_t color, snes_ntsc_rgb_t* out )
+{
+	int n;
+	for ( n = burst_count; n; --n )
+	{
+		unsigned i;
+		for ( i = 0; i < rgb_kernel_size / 2; i++ )
+		{
+			snes_ntsc_rgb_t error = color -
+					out [i    ] - out [(i+12)%14+14] - out [(i+10)%14+28] -
+					out [i + 7] - out [i + 5    +14] - out [i + 3    +28];
+			DISTRIBUTE_ERROR( i+3+28, i+5+14, i+7 );
+		}
+		out += alignment_count * rgb_kernel_size;
+	}
+}
+
+void snes_ntsc_init( snes_ntsc_t* ntsc, snes_ntsc_setup_t const* setup )
+{
+	int merge_fields;
+	int entry;
+	init_t impl;
+	if ( !setup )
+		setup = &snes_ntsc_composite;
+	init( &impl, setup );
+	
+	merge_fields = setup->merge_fields;
+	if ( setup->artifacts <= -1 && setup->fringing <= -1 )
+		merge_fields = 1;
+	
+	for ( entry = 0; entry < snes_ntsc_palette_size; entry++ )
+	{
+		/* Reduce number of significant bits of source color. Clearing the
+		low bits of R and B were least notictable. Modifying green was too
+		noticeable. */
+		int ir = entry >> 8 & 0x1E;
+		int ig = entry >> 4 & 0x1F;
+		int ib = entry << 1 & 0x1E;
+		
+		#if SNES_NTSC_BSNES_COLORTBL
+			if ( setup->bsnes_colortbl )
+			{
+				int bgr15 = (ib << 10) | (ig << 5) | ir;
+				unsigned long rgb16 = setup->bsnes_colortbl [bgr15];
+				ir = rgb16 >> 11 & 0x1E;
+				ig = rgb16 >>  6 & 0x1F;
+				ib = rgb16       & 0x1E;
+			}
+		#endif
+		
+		{
+			float rr = impl.to_float [ir];
+			float gg = impl.to_float [ig];
+			float bb = impl.to_float [ib];
+			
+			float y, i, q = RGB_TO_YIQ( rr, gg, bb, y, i );
+			
+			int r, g, b = YIQ_TO_RGB( y, i, q, impl.to_rgb, int, r, g );
+			snes_ntsc_rgb_t rgb = PACK_RGB( r, g, b );
+			
+			snes_ntsc_rgb_t* out = ntsc->table [entry];
+			gen_kernel( &impl, y, i, q, out );
+			if ( merge_fields )
+				merge_kernel_fields( out );
+			correct_errors( rgb, out );
+		}
+	}
+}
+
+#ifndef SNES_NTSC_NO_BLITTERS
+
+void snes_ntsc_blit( snes_ntsc_t const* ntsc, SNES_NTSC_IN_T const* input, long in_row_width,
+		int burst_phase, int in_width, int in_height, void* rgb_out, long out_pitch )
+{
+	int chunk_count = (in_width - 1) / snes_ntsc_in_chunk;
+	for ( ; in_height; --in_height )
+	{
+		SNES_NTSC_IN_T const* line_in = input;
+		SNES_NTSC_BEGIN_ROW( ntsc, burst_phase,
+				snes_ntsc_black, snes_ntsc_black, SNES_NTSC_ADJ_IN( *line_in ) );
+		snes_ntsc_out_t* restrict line_out = (snes_ntsc_out_t*) rgb_out;
+		int n;
+		++line_in;
+		
+		for ( n = chunk_count; n; --n )
+		{
+			/* order of input and output pixels must not be altered */
+			SNES_NTSC_COLOR_IN( 0, SNES_NTSC_ADJ_IN( line_in [0] ) );
+			SNES_NTSC_RGB_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_RGB_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 1, SNES_NTSC_ADJ_IN( line_in [1] ) );
+			SNES_NTSC_RGB_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_RGB_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 2, SNES_NTSC_ADJ_IN( line_in [2] ) );
+			SNES_NTSC_RGB_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_RGB_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_RGB_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
+			
+			line_in  += 3;
+			line_out += 7;
+		}
+		
+		/* finish final pixels */
+		SNES_NTSC_COLOR_IN( 0, snes_ntsc_black );
+		SNES_NTSC_RGB_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_RGB_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 1, snes_ntsc_black );
+		SNES_NTSC_RGB_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_RGB_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 2, snes_ntsc_black );
+		SNES_NTSC_RGB_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_RGB_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_RGB_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
+		
+		burst_phase = (burst_phase + 1) % snes_ntsc_burst_count;
+		input += in_row_width;
+		rgb_out = (char*) rgb_out + out_pitch;
+	}
+}
+
+void snes_ntsc_blit_hires( snes_ntsc_t const* ntsc, SNES_NTSC_IN_T const* input, long in_row_width,
+		int burst_phase, int in_width, int in_height, void* rgb_out, long out_pitch )
+{
+	int chunk_count = (in_width - 2) / (snes_ntsc_in_chunk * 2);
+	for ( ; in_height; --in_height )
+	{
+		SNES_NTSC_IN_T const* line_in = input;
+		SNES_NTSC_HIRES_ROW( ntsc, burst_phase,
+				snes_ntsc_black, snes_ntsc_black, snes_ntsc_black,
+				SNES_NTSC_ADJ_IN( line_in [0] ),
+				SNES_NTSC_ADJ_IN( line_in [1] ) );
+		snes_ntsc_out_t* restrict line_out = (snes_ntsc_out_t*) rgb_out;
+		int n;
+		line_in += 2;
+		
+		for ( n = chunk_count; n; --n )
+		{
+			/* twice as many input pixels per chunk */
+			SNES_NTSC_COLOR_IN( 0, SNES_NTSC_ADJ_IN( line_in [0] ) );
+			SNES_NTSC_HIRES_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 1, SNES_NTSC_ADJ_IN( line_in [1] ) );
+			SNES_NTSC_HIRES_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 2, SNES_NTSC_ADJ_IN( line_in [2] ) );
+			SNES_NTSC_HIRES_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 3, SNES_NTSC_ADJ_IN( line_in [3] ) );
+			SNES_NTSC_HIRES_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 4, SNES_NTSC_ADJ_IN( line_in [4] ) );
+			SNES_NTSC_HIRES_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
+			
+			SNES_NTSC_COLOR_IN( 5, SNES_NTSC_ADJ_IN( line_in [5] ) );
+			SNES_NTSC_HIRES_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
+			SNES_NTSC_HIRES_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
+			
+			line_in  += 6;
+			line_out += 7;
+		}
+		
+		SNES_NTSC_COLOR_IN( 0, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 0, line_out [0], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 1, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 1, line_out [1], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 2, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 2, line_out [2], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 3, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 3, line_out [3], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 4, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 4, line_out [4], SNES_NTSC_OUT_DEPTH );
+		
+		SNES_NTSC_COLOR_IN( 5, snes_ntsc_black );
+		SNES_NTSC_HIRES_OUT( 5, line_out [5], SNES_NTSC_OUT_DEPTH );
+		SNES_NTSC_HIRES_OUT( 6, line_out [6], SNES_NTSC_OUT_DEPTH );
+		
+		burst_phase = (burst_phase + 1) % snes_ntsc_burst_count;
+		input += in_row_width;
+		rgb_out = (char*) rgb_out + out_pitch;
+	}
+}
+
+#endif

bsnes/filter/snes_ntsc/snes_ntsc.h

@@ -0,0 +1,228 @@
+/* SNES NTSC video filter */
+
+/* snes_ntsc 0.2.2 */
+#ifndef SNES_NTSC_H
+#define SNES_NTSC_H
+
+#include "snes_ntsc_config.h"
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+/* Image parameters, ranging from -1.0 to 1.0. Actual internal values shown
+in parenthesis and should remain fairly stable in future versions. */
+typedef struct snes_ntsc_setup_t
+{
+	/* Basic parameters */
+	double hue;        /* -1 = -180 degrees     +1 = +180 degrees */
+	double saturation; /* -1 = grayscale (0.0)  +1 = oversaturated colors (2.0) */
+	double contrast;   /* -1 = dark (0.5)       +1 = light (1.5) */
+	double brightness; /* -1 = dark (0.5)       +1 = light (1.5) */
+	double sharpness;  /* edge contrast enhancement/blurring */
+	
+	/* Advanced parameters */
+	double gamma;      /* -1 = dark (1.5)       +1 = light (0.5) */
+	double resolution; /* image resolution */
+	double artifacts;  /* artifacts caused by color changes */
+	double fringing;   /* color artifacts caused by brightness changes */
+	double bleed;      /* color bleed (color resolution reduction) */
+	int merge_fields;  /* if 1, merges even and odd fields together to reduce flicker */
+	float const* decoder_matrix; /* optional RGB decoder matrix, 6 elements */
+	
+	unsigned long const* bsnes_colortbl; /* undocumented; set to 0 */
+} snes_ntsc_setup_t;
+
+/* Video format presets */
+extern snes_ntsc_setup_t const snes_ntsc_composite; /* color bleeding + artifacts */
+extern snes_ntsc_setup_t const snes_ntsc_svideo;    /* color bleeding only */
+extern snes_ntsc_setup_t const snes_ntsc_rgb;       /* crisp image */
+extern snes_ntsc_setup_t const snes_ntsc_monochrome;/* desaturated + artifacts */
+
+/* Initializes and adjusts parameters. Can be called multiple times on the same
+snes_ntsc_t object. Can pass NULL for either parameter. */
+typedef struct snes_ntsc_t snes_ntsc_t;
+void snes_ntsc_init( snes_ntsc_t* ntsc, snes_ntsc_setup_t const* setup );
+
+/* Filters one or more rows of pixels. Input pixel format is set by SNES_NTSC_IN_FORMAT
+and output RGB depth is set by SNES_NTSC_OUT_DEPTH. Both default to 16-bit RGB.
+In_row_width is the number of pixels to get to the next input row. Out_pitch
+is the number of *bytes* to get to the next output row. */
+void snes_ntsc_blit( snes_ntsc_t const* ntsc, SNES_NTSC_IN_T const* input,
+		long in_row_width, int burst_phase, int in_width, int in_height,
+		void* rgb_out, long out_pitch );
+
+void snes_ntsc_blit_hires( snes_ntsc_t const* ntsc, SNES_NTSC_IN_T const* input,
+		long in_row_width, int burst_phase, int in_width, int in_height,
+		void* rgb_out, long out_pitch );
+
+/* Number of output pixels written by low-res blitter for given input width. Width
+might be rounded down slightly; use SNES_NTSC_IN_WIDTH() on result to find rounded
+value. Guaranteed not to round 256 down at all. */
+#define SNES_NTSC_OUT_WIDTH( in_width ) \
+	((((in_width) - 1) / snes_ntsc_in_chunk + 1) * snes_ntsc_out_chunk)
+
+/* Number of low-res input pixels that will fit within given output width. Might be
+rounded down slightly; use SNES_NTSC_OUT_WIDTH() on result to find rounded
+value. */
+#define SNES_NTSC_IN_WIDTH( out_width ) \
+	(((out_width) / snes_ntsc_out_chunk - 1) * snes_ntsc_in_chunk + 1)
+
+
+/* Interface for user-defined custom blitters */
+
+enum { snes_ntsc_in_chunk    = 3  }; /* number of input pixels read per chunk */
+enum { snes_ntsc_out_chunk   = 7  }; /* number of output pixels generated per chunk */
+enum { snes_ntsc_black       = 0  }; /* palette index for black */
+enum { snes_ntsc_burst_count = 3  }; /* burst phase cycles through 0, 1, and 2 */
+
+/* Begins outputting row and starts three pixels. First pixel will be cut off a bit.
+Use snes_ntsc_black for unused pixels. Declares variables, so must be before first
+statement in a block (unless you're using C++). */
+#define SNES_NTSC_BEGIN_ROW( ntsc, burst, pixel0, pixel1, pixel2 ) \
+	char const* ktable = \
+		(char const*) (ntsc)->table + burst * (snes_ntsc_burst_size * sizeof (snes_ntsc_rgb_t));\
+	SNES_NTSC_BEGIN_ROW_6_( pixel0, pixel1, pixel2, SNES_NTSC_IN_FORMAT, ktable )
+
+/* Begins input pixel */
+#define SNES_NTSC_COLOR_IN( index, color ) \
+	SNES_NTSC_COLOR_IN_( index, color, SNES_NTSC_IN_FORMAT, ktable )
+
+/* Generates output pixel. Bits can be 24, 16, 15, 14, 32 (treated as 24), or 0:
+24:          RRRRRRRR GGGGGGGG BBBBBBBB (8-8-8 RGB)
+16:                   RRRRRGGG GGGBBBBB (5-6-5 RGB)
+15:                    RRRRRGG GGGBBBBB (5-5-5 RGB)
+14:                    BBBBBGG GGGRRRRR (5-5-5 BGR, native SNES format)
+ 0: xxxRRRRR RRRxxGGG GGGGGxxB BBBBBBBx (native internal format; x = junk bits) */
+#define SNES_NTSC_RGB_OUT( index, rgb_out, bits ) \
+	SNES_NTSC_RGB_OUT_14_( index, rgb_out, bits, 1 )
+
+/* Hires equivalents */
+#define SNES_NTSC_HIRES_ROW( ntsc, burst, pixel1, pixel2, pixel3, pixel4, pixel5 ) \
+	char const* ktable = \
+		(char const*) (ntsc)->table + burst * (snes_ntsc_burst_size * sizeof (snes_ntsc_rgb_t));\
+	unsigned const snes_ntsc_pixel1_ = (pixel1);\
+	snes_ntsc_rgb_t const* kernel1  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel1_ );\
+	unsigned const snes_ntsc_pixel2_ = (pixel2);\
+	snes_ntsc_rgb_t const* kernel2  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel2_ );\
+	unsigned const snes_ntsc_pixel3_ = (pixel3);\
+	snes_ntsc_rgb_t const* kernel3  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel3_ );\
+	unsigned const snes_ntsc_pixel4_ = (pixel4);\
+	snes_ntsc_rgb_t const* kernel4  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel4_ );\
+	unsigned const snes_ntsc_pixel5_ = (pixel5);\
+	snes_ntsc_rgb_t const* kernel5  = SNES_NTSC_IN_FORMAT( ktable, snes_ntsc_pixel5_ );\
+	snes_ntsc_rgb_t const* kernel0 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx0;\
+	snes_ntsc_rgb_t const* kernelx1 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx2 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx3 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx4 = kernel1;\
+	snes_ntsc_rgb_t const* kernelx5 = kernel1
+
+#define SNES_NTSC_HIRES_OUT( x, rgb_out, bits ) {\
+	snes_ntsc_rgb_t raw_ =\
+		kernel0  [ x       ] + kernel2  [(x+5)%7+14] + kernel4  [(x+3)%7+28] +\
+		kernelx0 [(x+7)%7+7] + kernelx2 [(x+5)%7+21] + kernelx4 [(x+3)%7+35] +\
+		kernel1  [(x+6)%7  ] + kernel3  [(x+4)%7+14] + kernel5  [(x+2)%7+28] +\
+		kernelx1 [(x+6)%7+7] + kernelx3 [(x+4)%7+21] + kernelx5 [(x+2)%7+35];\
+	SNES_NTSC_CLAMP_( raw_, 0 );\
+	SNES_NTSC_RGB_OUT_( rgb_out, (bits), 0 );\
+}
+
+
+/* private */
+enum { snes_ntsc_entry_size = 128 };
+enum { snes_ntsc_palette_size = 0x2000 };
+typedef unsigned long snes_ntsc_rgb_t;
+struct snes_ntsc_t {
+	snes_ntsc_rgb_t table [snes_ntsc_palette_size] [snes_ntsc_entry_size];
+};
+enum { snes_ntsc_burst_size = snes_ntsc_entry_size / snes_ntsc_burst_count };
+
+#define SNES_NTSC_RGB16( ktable, n ) \
+	(snes_ntsc_rgb_t const*) (ktable + ((n & 0x001E) | (n >> 1 & 0x03E0) | (n >> 2 & 0x3C00)) * \
+			(snes_ntsc_entry_size / 2 * sizeof (snes_ntsc_rgb_t)))
+
+#define SNES_NTSC_BGR15( ktable, n ) \
+	(snes_ntsc_rgb_t const*) (ktable + ((n << 9 & 0x3C00) | (n & 0x03E0) | (n >> 10 & 0x001E)) * \
+			(snes_ntsc_entry_size / 2 * sizeof (snes_ntsc_rgb_t)))
+
+/* common 3->7 ntsc macros */
+#define SNES_NTSC_BEGIN_ROW_6_( pixel0, pixel1, pixel2, ENTRY, table ) \
+	unsigned const snes_ntsc_pixel0_ = (pixel0);\
+	snes_ntsc_rgb_t const* kernel0  = ENTRY( table, snes_ntsc_pixel0_ );\
+	unsigned const snes_ntsc_pixel1_ = (pixel1);\
+	snes_ntsc_rgb_t const* kernel1  = ENTRY( table, snes_ntsc_pixel1_ );\
+	unsigned const snes_ntsc_pixel2_ = (pixel2);\
+	snes_ntsc_rgb_t const* kernel2  = ENTRY( table, snes_ntsc_pixel2_ );\
+	snes_ntsc_rgb_t const* kernelx0;\
+	snes_ntsc_rgb_t const* kernelx1 = kernel0;\
+	snes_ntsc_rgb_t const* kernelx2 = kernel0
+
+#define SNES_NTSC_RGB_OUT_14_( x, rgb_out, bits, shift ) {\
+	snes_ntsc_rgb_t raw_ =\
+		kernel0  [x       ] + kernel1  [(x+12)%7+14] + kernel2  [(x+10)%7+28] +\
+		kernelx0 [(x+7)%14] + kernelx1 [(x+ 5)%7+21] + kernelx2 [(x+ 3)%7+35];\
+	SNES_NTSC_CLAMP_( raw_, shift );\
+	SNES_NTSC_RGB_OUT_( rgb_out, bits, shift );\
+}
+
+/* common ntsc macros */
+#define snes_ntsc_rgb_builder    ((1L << 21) | (1 << 11) | (1 << 1))
+#define snes_ntsc_clamp_mask     (snes_ntsc_rgb_builder * 3 / 2)
+#define snes_ntsc_clamp_add      (snes_ntsc_rgb_builder * 0x101)
+#define SNES_NTSC_CLAMP_( io, shift ) {\
+	snes_ntsc_rgb_t sub = (io) >> (9-(shift)) & snes_ntsc_clamp_mask;\
+	snes_ntsc_rgb_t clamp = snes_ntsc_clamp_add - sub;\
+	io |= clamp;\
+	clamp -= sub;\
+	io &= clamp;\
+}
+
+#define SNES_NTSC_COLOR_IN_( index, color, ENTRY, table ) {\
+	unsigned color_;\
+	kernelx##index = kernel##index;\
+	kernel##index = (color_ = (color), ENTRY( table, color_ ));\
+}
+
+/* x is always zero except in snes_ntsc library */
+/* original routine */
+/*
+#define SNES_NTSC_RGB_OUT_( rgb_out, bits, x ) {\
+	if ( bits == 16 )\
+		rgb_out = (raw_>>(13-x)& 0xF800)|(raw_>>(8-x)&0x07E0)|(raw_>>(4-x)&0x001F);\
+	if ( bits == 24 || bits == 32 )\
+		rgb_out = (raw_>>(5-x)&0xFF0000)|(raw_>>(3-x)&0xFF00)|(raw_>>(1-x)&0xFF);\
+	if ( bits == 15 )\
+		rgb_out = (raw_>>(14-x)& 0x7C00)|(raw_>>(9-x)&0x03E0)|(raw_>>(4-x)&0x001F);\
+	if ( bits == 14 )\
+		rgb_out = (raw_>>(24-x)& 0x001F)|(raw_>>(9-x)&0x03E0)|(raw_<<(6+x)&0x7C00);\
+	if ( bits == 0 )\
+		rgb_out = raw_ << x;\
+}
+*/
+
+/* custom bsnes routine -- hooks into bsnes colortable */
+#define SNES_NTSC_RGB_OUT_( rgb_out, bits, x ) {\
+	if ( bits == 16 ) {\
+		rgb_out = (raw_>>(13-x)& 0xF800)|(raw_>>(8-x)&0x07E0)|(raw_>>(4-x)&0x001F);\
+		rgb_out = ((rgb_out&0xf800)>>11)|((rgb_out&0x07c0)>>1)|((rgb_out&0x001f)<<10);\
+		rgb_out = colortable[rgb_out];\
+	} else if ( bits == 24 || bits == 32 ) {\
+		rgb_out = (raw_>>(5-x)&0xFF0000)|(raw_>>(3-x)&0xFF00)|(raw_>>(1-x)&0xFF);\
+		rgb_out = ((rgb_out&0xf80000)>>19)|((rgb_out&0x00f800)>>6)|((rgb_out&0x0000f8)<<7);\
+		rgb_out = colortable[rgb_out];\
+	} else if ( bits == 15 ) {\
+		rgb_out = (raw_>>(14-x)& 0x7C00)|(raw_>>(9-x)&0x03E0)|(raw_>>(4-x)&0x001F);\
+		rgb_out = ((rgb_out&0x7c00)>>10)|((rgb_out&0x03e0))|((rgb_out&0x001f)<<10);\
+		rgb_out = colortable[rgb_out];\
+	} else {\
+		rgb_out = raw_ << x;\
+	}\
+}
+
+#ifdef __cplusplus
+	}
+#endif
+
+#endif

bsnes/filter/snes_ntsc/snes_ntsc_config.h

@@ -0,0 +1,26 @@
+/* Configure library by modifying this file */
+
+#ifndef SNES_NTSC_CONFIG_H
+#define SNES_NTSC_CONFIG_H
+
+/* Format of source pixels */
+/* #define SNES_NTSC_IN_FORMAT SNES_NTSC_RGB16 */
+#define SNES_NTSC_IN_FORMAT SNES_NTSC_BGR15
+
+/* The following affect the built-in blitter only; a custom blitter can
+handle things however it wants. */
+
+/* Bits per pixel of output. Can be 15, 16, 32, or 24 (same as 32). */
+#define SNES_NTSC_OUT_DEPTH 32
+
+/* Type of input pixel values */
+#define SNES_NTSC_IN_T unsigned short
+
+/* Each raw pixel input value is passed through this. You might want to mask
+the pixel index if you use the high bits as flags, etc. */
+#define SNES_NTSC_ADJ_IN( in ) in
+
+/* For each pixel, this is the basic operation:
+output_color = SNES_NTSC_ADJ_IN( SNES_NTSC_IN_T ) */
+
+#endif

bsnes/filter/snes_ntsc/snes_ntsc_impl.h

@@ -0,0 +1,439 @@
+/* snes_ntsc 0.2.2. http://www.slack.net/~ant/ */
+
+/* Common implementation of NTSC filters */
+
+#include <assert.h>
+#include <math.h>
+
+/* Copyright (C) 2006 Shay Green. This module is free software; you
+can redistribute it and/or modify it under the terms of the GNU Lesser
+General Public License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version. This
+module is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+details. You should have received a copy of the GNU Lesser General Public
+License along with this module; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#define DISABLE_CORRECTION 0
+
+#undef PI
+#define PI 3.14159265358979323846f
+
+#ifndef LUMA_CUTOFF
+	#define LUMA_CUTOFF 0.20
+#endif
+#ifndef gamma_size
+	#define gamma_size 1
+#endif
+#ifndef rgb_bits
+	#define rgb_bits 8
+#endif
+#ifndef artifacts_max
+	#define artifacts_max (artifacts_mid * 1.5f)
+#endif
+#ifndef fringing_max
+	#define fringing_max (fringing_mid * 2)
+#endif
+#ifndef STD_HUE_CONDITION
+	#define STD_HUE_CONDITION( setup ) 1
+#endif
+
+#define ext_decoder_hue     (std_decoder_hue + 15)
+#define rgb_unit            (1 << rgb_bits)
+#define rgb_offset          (rgb_unit * 2 + 0.5f)
+
+enum { burst_size  = snes_ntsc_entry_size / burst_count };
+enum { kernel_half = 16 };
+enum { kernel_size = kernel_half * 2 + 1 };
+
+typedef struct init_t
+{
+	float to_rgb [burst_count * 6];
+	float to_float [gamma_size];
+	float contrast;
+	float brightness;
+	float artifacts;
+	float fringing;
+	float kernel [rescale_out * kernel_size * 2];
+} init_t;
+
+#define ROTATE_IQ( i, q, sin_b, cos_b ) {\
+	float t;\
+	t = i * cos_b - q * sin_b;\
+	q = i * sin_b + q * cos_b;\
+	i = t;\
+}
+
+static void init_filters( init_t* impl, snes_ntsc_setup_t const* setup )
+{
+#if rescale_out > 1
+	float kernels [kernel_size * 2];
+#else
+	float* const kernels = impl->kernel;
+#endif
+
+	/* generate luma (y) filter using sinc kernel */
+	{
+		/* sinc with rolloff (dsf) */
+		float const rolloff = 1 + (float) setup->sharpness * (float) 0.032;
+		float const maxh = 32;
+		float const pow_a_n = (float) pow( rolloff, maxh );
+		float sum;
+		int i;
+		/* quadratic mapping to reduce negative (blurring) range */
+		float to_angle = (float) setup->resolution + 1;
+		to_angle = PI / maxh * (float) LUMA_CUTOFF * (to_angle * to_angle + 1);
+		
+		kernels [kernel_size * 3 / 2] = maxh; /* default center value */
+		for ( i = 0; i < kernel_half * 2 + 1; i++ )
+		{
+			int x = i - kernel_half;
+			float angle = x * to_angle;
+			/* instability occurs at center point with rolloff very close to 1.0 */
+			if ( x || pow_a_n > (float) 1.056 || pow_a_n < (float) 0.981 )
+			{
+				float rolloff_cos_a = rolloff * (float) cos( angle );
+				float num = 1 - rolloff_cos_a -
+						pow_a_n * (float) cos( maxh * angle ) +
+						pow_a_n * rolloff * (float) cos( (maxh - 1) * angle );
+				float den = 1 - rolloff_cos_a - rolloff_cos_a + rolloff * rolloff;
+				float dsf = num / den;
+				kernels [kernel_size * 3 / 2 - kernel_half + i] = dsf - (float) 0.5;
+			}
+		}
+		
+		/* apply blackman window and find sum */
+		sum = 0;
+		for ( i = 0; i < kernel_half * 2 + 1; i++ )
+		{
+			float x = PI * 2 / (kernel_half * 2) * i;
+			float blackman = 0.42f - 0.5f * (float) cos( x ) + 0.08f * (float) cos( x * 2 );
+			sum += (kernels [kernel_size * 3 / 2 - kernel_half + i] *= blackman);
+		}
+		
+		/* normalize kernel */
+		sum = 1.0f / sum;
+		for ( i = 0; i < kernel_half * 2 + 1; i++ )
+		{
+			int x = kernel_size * 3 / 2 - kernel_half + i;
+			kernels [x] *= sum;
+			assert( kernels [x] == kernels [x] ); /* catch numerical instability */
+		}
+	}
+
+	/* generate chroma (iq) filter using gaussian kernel */
+	{
+		float const cutoff_factor = -0.03125f;
+		float cutoff = (float) setup->bleed;
+		int i;
+		
+		if ( cutoff < 0 )
+		{
+			/* keep extreme value accessible only near upper end of scale (1.0) */
+			cutoff *= cutoff;
+			cutoff *= cutoff;
+			cutoff *= cutoff;
+			cutoff *= -30.0f / 0.65f;
+		}
+		cutoff = cutoff_factor - 0.65f * cutoff_factor * cutoff;
+		
+		for ( i = -kernel_half; i <= kernel_half; i++ )
+			kernels [kernel_size / 2 + i] = (float) exp( i * i * cutoff );
+		
+		/* normalize even and odd phases separately */
+		for ( i = 0; i < 2; i++ )
+		{
+			float sum = 0;
+			int x;
+			for ( x = i; x < kernel_size; x += 2 )
+				sum += kernels [x];
+			
+			sum = 1.0f / sum;
+			for ( x = i; x < kernel_size; x += 2 )
+			{
+				kernels [x] *= sum;
+				assert( kernels [x] == kernels [x] ); /* catch numerical instability */
+			}
+		}
+	}
+	
+	/*
+	printf( "luma:\n" );
+	for ( i = kernel_size; i < kernel_size * 2; i++ )
+		printf( "%f\n", kernels [i] );
+	printf( "chroma:\n" );
+	for ( i = 0; i < kernel_size; i++ )
+		printf( "%f\n", kernels [i] );
+	*/
+	
+	/* generate linear rescale kernels */
+	#if rescale_out > 1
+	{
+		float weight = 1.0f;
+		float* out = impl->kernel;
+		int n = rescale_out;
+		do
+		{
+			float remain = 0;
+			int i;
+			weight -= 1.0f / rescale_in;
+			for ( i = 0; i < kernel_size * 2; i++ )
+			{
+				float cur = kernels [i];
+				float m = cur * weight;
+				*out++ = m + remain;
+				remain = cur - m;
+			}
+		}
+		while ( --n );
+	}
+	#endif
+}
+
+static float const default_decoder [6] =
+	{ 0.956f, 0.621f, -0.272f, -0.647f, -1.105f, 1.702f };
+
+static void init( init_t* impl, snes_ntsc_setup_t const* setup )
+{
+	impl->brightness = (float) setup->brightness * (0.5f * rgb_unit) + rgb_offset;
+	impl->contrast   = (float) setup->contrast   * (0.5f * rgb_unit) + rgb_unit;
+	#ifdef default_palette_contrast
+		if ( !setup->palette )
+			impl->contrast *= default_palette_contrast;
+	#endif
+	
+	impl->artifacts = (float) setup->artifacts;
+	if ( impl->artifacts > 0 )
+		impl->artifacts *= artifacts_max - artifacts_mid;
+	impl->artifacts = impl->artifacts * artifacts_mid + artifacts_mid;
+
+	impl->fringing = (float) setup->fringing;
+	if ( impl->fringing > 0 )
+		impl->fringing *= fringing_max - fringing_mid;
+	impl->fringing = impl->fringing * fringing_mid + fringing_mid;
+	
+	init_filters( impl, setup );
+	
+	/* generate gamma table */
+	if ( gamma_size > 1 )
+	{
+		float const to_float = 1.0f / (gamma_size - (gamma_size > 1));
+		float const gamma = 1.1333f - (float) setup->gamma * 0.5f;
+		/* match common PC's 2.2 gamma to TV's 2.65 gamma */
+		int i;
+		for ( i = 0; i < gamma_size; i++ )
+			impl->to_float [i] =
+					(float) pow( i * to_float, gamma ) * impl->contrast + impl->brightness;
+	}
+	
+	/* setup decoder matricies */
+	{
+		float hue = (float) setup->hue * PI + PI / 180 * ext_decoder_hue;
+		float sat = (float) setup->saturation + 1;
+		float const* decoder = setup->decoder_matrix;
+		if ( !decoder )
+		{
+			decoder = default_decoder;
+			if ( STD_HUE_CONDITION( setup ) )
+				hue += PI / 180 * (std_decoder_hue - ext_decoder_hue);
+		}
+		
+		{
+			float s = (float) sin( hue ) * sat;
+			float c = (float) cos( hue ) * sat;
+			float* out = impl->to_rgb;
+			int n;
+			
+			n = burst_count;
+			do
+			{
+				float const* in = decoder;
+				int n = 3;
+				do
+				{
+					float i = *in++;
+					float q = *in++;
+					*out++ = i * c - q * s;
+					*out++ = i * s + q * c;
+				}
+				while ( --n );
+				if ( burst_count <= 1 )
+					break;
+				ROTATE_IQ( s, c, 0.866025f, -0.5f ); /* +120 degrees */
+			}
+			while ( --n );
+		}
+	}
+}
+
+/* kernel generation */
+
+#define RGB_TO_YIQ( r, g, b, y, i ) (\
+	(y = (r) * 0.299f + (g) * 0.587f + (b) * 0.114f),\
+	(i = (r) * 0.596f - (g) * 0.275f - (b) * 0.321f),\
+	((r) * 0.212f - (g) * 0.523f + (b) * 0.311f)\
+)
+
+#define YIQ_TO_RGB( y, i, q, to_rgb, type, r, g ) (\
+	r = (type) (y + to_rgb [0] * i + to_rgb [1] * q),\
+	g = (type) (y + to_rgb [2] * i + to_rgb [3] * q),\
+	(type) (y + to_rgb [4] * i + to_rgb [5] * q)\
+)
+
+#define PACK_RGB( r, g, b ) ((r) << 21 | (g) << 11 | (b) << 1)
+
+enum { rgb_kernel_size = burst_size / alignment_count };
+enum { rgb_bias = rgb_unit * 2 * snes_ntsc_rgb_builder };
+
+typedef struct pixel_info_t
+{
+	int offset;
+	float negate;
+	float kernel [4];
+} pixel_info_t;
+
+#if rescale_in > 1
+	#define PIXEL_OFFSET_( ntsc, scaled ) \
+		(kernel_size / 2 + ntsc + (scaled != 0) + (rescale_out - scaled) % rescale_out + \
+				(kernel_size * 2 * scaled))
+
+	#define PIXEL_OFFSET( ntsc, scaled ) \
+		PIXEL_OFFSET_( ((ntsc) - (scaled) / rescale_out * rescale_in),\
+				(((scaled) + rescale_out * 10) % rescale_out) ),\
+		(1.0f - (((ntsc) + 100) & 2))
+#else
+	#define PIXEL_OFFSET( ntsc, scaled ) \
+		(kernel_size / 2 + (ntsc) - (scaled)),\
+		(1.0f - (((ntsc) + 100) & 2))
+#endif
+
+extern pixel_info_t const snes_ntsc_pixels [alignment_count];
+
+/* Generate pixel at all burst phases and column alignments */
+static void gen_kernel( init_t* impl, float y, float i, float q, snes_ntsc_rgb_t* out )
+{
+	/* generate for each scanline burst phase */
+	float const* to_rgb = impl->to_rgb;
+	int burst_remain = burst_count;
+	y -= rgb_offset;
+	do
+	{
+		/* Encode yiq into *two* composite signals (to allow control over artifacting).
+		Convolve these with kernels which: filter respective components, apply
+		sharpening, and rescale horizontally. Convert resulting yiq to rgb and pack
+		into integer. Based on algorithm by NewRisingSun. */
+		pixel_info_t const* pixel = snes_ntsc_pixels;
+		int alignment_remain = alignment_count;
+		do
+		{
+			/* negate is -1 when composite starts at odd multiple of 2 */
+			float const yy = y * impl->fringing * pixel->negate;
+			float const ic0 = (i + yy) * pixel->kernel [0];
+			float const qc1 = (q + yy) * pixel->kernel [1];
+			float const ic2 = (i - yy) * pixel->kernel [2];
+			float const qc3 = (q - yy) * pixel->kernel [3];
+			
+			float const factor = impl->artifacts * pixel->negate;
+			float const ii = i * factor;
+			float const yc0 = (y + ii) * pixel->kernel [0];
+			float const yc2 = (y - ii) * pixel->kernel [2];
+			
+			float const qq = q * factor;
+			float const yc1 = (y + qq) * pixel->kernel [1];
+			float const yc3 = (y - qq) * pixel->kernel [3];
+			
+			float const* k = &impl->kernel [pixel->offset];
+			int n;
+			++pixel;
+			for ( n = rgb_kernel_size; n; --n )
+			{
+				float i = k[0]*ic0 + k[2]*ic2;
+				float q = k[1]*qc1 + k[3]*qc3;
+				float y = k[kernel_size+0]*yc0 + k[kernel_size+1]*yc1 +
+				          k[kernel_size+2]*yc2 + k[kernel_size+3]*yc3 + rgb_offset;
+				if ( rescale_out <= 1 )
+					k--;
+				else if ( k < &impl->kernel [kernel_size * 2 * (rescale_out - 1)] )
+					k += kernel_size * 2 - 1;
+				else
+					k -= kernel_size * 2 * (rescale_out - 1) + 2;
+				{
+					int r, g, b = YIQ_TO_RGB( y, i, q, to_rgb, int, r, g );
+					*out++ = PACK_RGB( r, g, b ) - rgb_bias;
+				}
+			}
+		}
+		while ( alignment_count > 1 && --alignment_remain );
+		
+		if ( burst_count <= 1 )
+			break;
+		
+		to_rgb += 6;
+		
+		ROTATE_IQ( i, q, -0.866025f, -0.5f ); /* -120 degrees */
+	}
+	while ( --burst_remain );
+}
+
+static void correct_errors( snes_ntsc_rgb_t color, snes_ntsc_rgb_t* out );
+
+#if DISABLE_CORRECTION
+	#define CORRECT_ERROR( a ) { out [i] += rgb_bias; }
+	#define DISTRIBUTE_ERROR( a, b, c ) { out [i] += rgb_bias; }
+#else
+	#define CORRECT_ERROR( a ) { out [a] += error; }
+	#define DISTRIBUTE_ERROR( a, b, c ) {\
+		snes_ntsc_rgb_t fourth = (error + 2 * snes_ntsc_rgb_builder) >> 2;\
+		fourth &= (rgb_bias >> 1) - snes_ntsc_rgb_builder;\
+		fourth -= rgb_bias >> 2;\
+		out [a] += fourth;\
+		out [b] += fourth;\
+		out [c] += fourth;\
+		out [i] += error - (fourth * 3);\
+	}
+#endif
+
+#define RGB_PALETTE_OUT( rgb, out_ )\
+{\
+	unsigned char* out = (out_);\
+	snes_ntsc_rgb_t clamped = (rgb);\
+	SNES_NTSC_CLAMP_( clamped, (8 - rgb_bits) );\
+	out [0] = (unsigned char) (clamped >> 21);\
+	out [1] = (unsigned char) (clamped >> 11);\
+	out [2] = (unsigned char) (clamped >>  1);\
+}
+
+/* blitter related */
+
+#ifndef restrict
+	#if defined (__GNUC__)
+		#define restrict __restrict__
+	#elif defined (_MSC_VER) && _MSC_VER > 1300
+		#define restrict __restrict
+	#else
+		/* no support for restricted pointers */
+		#define restrict
+	#endif
+#endif
+
+#include <limits.h>
+
+#if SNES_NTSC_OUT_DEPTH <= 16
+	#if USHRT_MAX == 0xFFFF
+		typedef unsigned short snes_ntsc_out_t;
+	#else
+		#error "Need 16-bit int type"
+	#endif
+
+#else
+	#if UINT_MAX == 0xFFFFFFFF
+		typedef unsigned int  snes_ntsc_out_t;
+	#elif ULONG_MAX == 0xFFFFFFFF
+		typedef unsigned long snes_ntsc_out_t;
+	#else
+		#error "Need 32-bit int type"
+	#endif
+
+#endif

bsnes/filter/super-2xsai.cpp

@@ -0,0 +1,25 @@
+namespace Filter::Super2xSaI {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+uint32_t temp[512 * 480];
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t*)(((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * width;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  Super2xSaI32((unsigned char*)temp, width * sizeof(uint32_t), 0, (unsigned char*)output, outpitch, width, height);
+}
+
+}

bsnes/filter/super-eagle.cpp

@@ -0,0 +1,25 @@
+namespace Filter::SuperEagle {
+
+auto size(uint& width, uint& height) -> void {
+  width  *= 2;
+  height *= 2;
+}
+
+uint32_t temp[512 * 480];
+
+auto render(
+  uint32_t* colortable, uint32_t* output, uint outpitch,
+  const uint16_t* input, uint pitch, uint width, uint height
+) -> void {
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t*)(((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * width;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  SuperEagle32((unsigned char*)temp, width * sizeof(uint32_t), 0, (unsigned char*)output, outpitch, width, height);
+}
+
+}

bsnes/gb/Core/apu.c

@@ -0,0 +1,991 @@
+#include <stdint.h>
+#include <math.h>
+#include <string.h>
+#include <assert.h>
+#include "gb.h"
+
+#define likely(x)   __builtin_expect((x), 1)
+#define unlikely(x) __builtin_expect((x), 0)
+
+static const uint8_t duties[] = {
+    0, 0, 0, 0, 0, 0, 0, 1,
+    1, 0, 0, 0, 0, 0, 0, 1,
+    1, 0, 0, 0, 0, 1, 1, 1,
+    0, 1, 1, 1, 1, 1, 1, 0,
+};
+
+static void refresh_channel(GB_gameboy_t *gb, unsigned index, unsigned cycles_offset)
+{
+    unsigned multiplier = gb->apu_output.cycles_since_render + cycles_offset - gb->apu_output.last_update[index];
+    gb->apu_output.summed_samples[index].left += gb->apu_output.current_sample[index].left * multiplier;
+    gb->apu_output.summed_samples[index].right += gb->apu_output.current_sample[index].right * multiplier;
+    gb->apu_output.last_update[index] = gb->apu_output.cycles_since_render + cycles_offset;
+}
+
+bool GB_apu_is_DAC_enabled(GB_gameboy_t *gb, unsigned index)
+{
+    if (gb->model >= GB_MODEL_AGB) {
+        /* On the AGB, mixing is done digitally, so there are no per-channel
+           DACs. Instead, all channels are summed digital regardless of
+           whatever the DAC state would be on a CGB or earlier model. */
+        return true;
+    }
+    
+    switch (index) {
+        case GB_SQUARE_1:
+            return gb->io_registers[GB_IO_NR12] & 0xF8;
+
+        case GB_SQUARE_2:
+            return gb->io_registers[GB_IO_NR22] & 0xF8;
+
+        case GB_WAVE:
+            return gb->apu.wave_channel.enable;
+
+        case GB_NOISE:
+            return gb->io_registers[GB_IO_NR42] & 0xF8;
+    }
+
+    return false;
+}
+
+static void update_sample(GB_gameboy_t *gb, unsigned index, int8_t value, unsigned cycles_offset)
+{
+    if (gb->model >= GB_MODEL_AGB) {
+        /* On the AGB, because no analog mixing is done, the behavior of NR51 is a bit different.
+           A channel that is not connected to a terminal is idenitcal to a connected channel
+           playing PCM sample 0. */
+        gb->apu.samples[index] = value;
+        
+        if (gb->apu_output.sample_rate) {
+            unsigned right_volume = (gb->io_registers[GB_IO_NR50] & 7) + 1;
+            unsigned left_volume = ((gb->io_registers[GB_IO_NR50] >> 4) & 7) + 1;
+            
+            if (index == GB_WAVE) {
+                /* For some reason, channel 3 is inverted on the AGB */
+                value ^= 0xF;
+            }
+            
+            GB_sample_t output;
+            if (gb->io_registers[GB_IO_NR51] & (1 << index)) {
+                output.right = (0xf - value * 2) * right_volume;
+            }
+            else {
+                output.right = 0xf * right_volume;
+            }
+            
+            if (gb->io_registers[GB_IO_NR51] & (0x10 << index)) {
+                output.left = (0xf - value * 2) * left_volume;
+            }
+            else {
+                output.left = 0xf * left_volume;
+            }
+            
+            if (*(uint32_t *)&(gb->apu_output.current_sample[index]) != *(uint32_t *)&output) {
+                refresh_channel(gb, index, cycles_offset);
+                gb->apu_output.current_sample[index] = output;
+            }
+        }
+        
+        return;
+    }
+    
+    if (!GB_apu_is_DAC_enabled(gb, index)) {
+        value = gb->apu.samples[index];
+    }
+    else {
+        gb->apu.samples[index] = value;
+    }
+
+    if (gb->apu_output.sample_rate) {
+        unsigned right_volume = 0;
+        if (gb->io_registers[GB_IO_NR51] & (1 << index)) {
+            right_volume = (gb->io_registers[GB_IO_NR50] & 7) + 1;
+        }
+        unsigned left_volume = 0;
+        if (gb->io_registers[GB_IO_NR51] & (0x10 << index)) {
+            left_volume = ((gb->io_registers[GB_IO_NR50] >> 4) & 7) + 1;
+        }
+        GB_sample_t output = {(0xf - value * 2) * left_volume, (0xf - value * 2) * right_volume};
+        if (*(uint32_t *)&(gb->apu_output.current_sample[index]) != *(uint32_t *)&output) {
+            refresh_channel(gb, index, cycles_offset);
+            gb->apu_output.current_sample[index] = output;
+        }
+    }
+}
+
+static double smooth(double x)
+{
+    return 3*x*x - 2*x*x*x;
+}
+
+static void render(GB_gameboy_t *gb)
+{
+    GB_sample_t output = {0,0};
+
+    UNROLL
+    for (unsigned i = 0; i < GB_N_CHANNELS; i++) {
+        double multiplier = CH_STEP;
+        
+        if (gb->model < GB_MODEL_AGB) {
+            if (!GB_apu_is_DAC_enabled(gb, i)) {
+                gb->apu_output.dac_discharge[i] -= ((double) DAC_DECAY_SPEED) / gb->apu_output.sample_rate;
+                if (gb->apu_output.dac_discharge[i] < 0) {
+                    multiplier = 0;
+                    gb->apu_output.dac_discharge[i] = 0;
+                }
+                else {
+                    multiplier *= smooth(gb->apu_output.dac_discharge[i]);
+                }
+            }
+            else {
+                gb->apu_output.dac_discharge[i] += ((double) DAC_ATTACK_SPEED) / gb->apu_output.sample_rate;
+                if (gb->apu_output.dac_discharge[i] > 1) {
+                    gb->apu_output.dac_discharge[i] = 1;
+                }
+                else {
+                    multiplier *= smooth(gb->apu_output.dac_discharge[i]);
+                }
+            }
+        }
+
+        if (likely(gb->apu_output.last_update[i] == 0)) {
+            output.left += gb->apu_output.current_sample[i].left * multiplier;
+            output.right += gb->apu_output.current_sample[i].right * multiplier;
+        }
+        else {
+            refresh_channel(gb, i, 0);
+            output.left += (signed long) gb->apu_output.summed_samples[i].left * multiplier
+                            / gb->apu_output.cycles_since_render;
+            output.right += (signed long) gb->apu_output.summed_samples[i].right * multiplier
+                            / gb->apu_output.cycles_since_render;
+            gb->apu_output.summed_samples[i] = (GB_sample_t){0, 0};
+        }
+        gb->apu_output.last_update[i] = 0;
+    }
+    gb->apu_output.cycles_since_render = 0;
+
+    GB_sample_t filtered_output = gb->apu_output.highpass_mode?
+        (GB_sample_t) {output.left - gb->apu_output.highpass_diff.left,
+                       output.right - gb->apu_output.highpass_diff.right} :
+        output;
+
+    switch (gb->apu_output.highpass_mode) {
+        case GB_HIGHPASS_OFF:
+            gb->apu_output.highpass_diff = (GB_double_sample_t) {0, 0};
+            break;
+        case GB_HIGHPASS_ACCURATE:
+            gb->apu_output.highpass_diff = (GB_double_sample_t)
+                {output.left - filtered_output.left * gb->apu_output.highpass_rate,
+                    output.right - filtered_output.right * gb->apu_output.highpass_rate};
+            break;
+        case GB_HIGHPASS_REMOVE_DC_OFFSET: {
+            unsigned mask = gb->io_registers[GB_IO_NR51];
+            unsigned left_volume = 0;
+            unsigned right_volume = 0;
+            UNROLL
+            for (unsigned i = GB_N_CHANNELS; i--;) {
+                if (gb->apu.is_active[i]) {
+                    if (mask & 1) {
+                        left_volume += (gb->io_registers[GB_IO_NR50] & 7) * CH_STEP * 0xF;
+                    }
+                    if (mask & 0x10) {
+                        right_volume += ((gb->io_registers[GB_IO_NR50] >> 4) & 7) * CH_STEP * 0xF;
+                    }
+                }
+                else {
+                    left_volume += gb->apu_output.current_sample[i].left * CH_STEP;
+                    right_volume += gb->apu_output.current_sample[i].right * CH_STEP;
+                }
+                mask >>= 1;
+            }
+            gb->apu_output.highpass_diff = (GB_double_sample_t)
+            {left_volume * (1 - gb->apu_output.highpass_rate) + gb->apu_output.highpass_diff.left * gb->apu_output.highpass_rate,
+                right_volume * (1 - gb->apu_output.highpass_rate) + gb->apu_output.highpass_diff.right * gb->apu_output.highpass_rate};
+
+        case GB_HIGHPASS_MAX:;
+        }
+
+    }
+    
+    assert(gb->apu_output.sample_callback);
+    gb->apu_output.sample_callback(gb, &filtered_output);
+}
+
+static uint16_t new_sweep_sample_legnth(GB_gameboy_t *gb)
+{
+    uint16_t delta = gb->apu.shadow_sweep_sample_legnth >> (gb->io_registers[GB_IO_NR10] & 7);
+    if (gb->io_registers[GB_IO_NR10] & 8) {
+        return gb->apu.shadow_sweep_sample_legnth - delta;
+    }
+    return gb->apu.shadow_sweep_sample_legnth + delta;
+}
+
+static void update_square_sample(GB_gameboy_t *gb, unsigned index)
+{
+    if (gb->apu.square_channels[index].current_sample_index & 0x80) return;
+
+    uint8_t duty = gb->io_registers[index == GB_SQUARE_1? GB_IO_NR11 :GB_IO_NR21] >> 6;
+    update_sample(gb, index,
+                  duties[gb->apu.square_channels[index].current_sample_index + duty * 8]?
+                  gb->apu.square_channels[index].current_volume : 0,
+                  0);
+}
+
+
+/* the effects of NRX2 writes on current volume are not well documented and differ
+   between models and variants. The exact behavior can only be verified on CGB as it
+   requires the PCM12 register. The behavior implemented here was verified on *my*
+   CGB, which might behave differently from other CGB revisions, as well as from the
+   DMG, MGB or SGB/2 */
+static void nrx2_glitch(uint8_t *volume, uint8_t value, uint8_t old_value)
+{
+    if (value & 8) {
+        (*volume)++;
+    }
+
+    if (((value ^ old_value) & 8)) {
+        *volume = 0x10 - *volume;
+    }
+
+    if ((value & 7) && !(old_value & 7) && *volume && !(value & 8)) {
+        (*volume)--;
+    }
+
+    if ((old_value & 7) && (value & 8)) {
+        (*volume)--;
+    }
+
+    (*volume) &= 0xF;
+}
+
+static void tick_square_envelope(GB_gameboy_t *gb, enum GB_CHANNELS index)
+{
+    uint8_t nrx2 = gb->io_registers[index == GB_SQUARE_1? GB_IO_NR12 : GB_IO_NR22];
+
+    if (gb->apu.square_channels[index].volume_countdown || (nrx2 & 7)) {
+        if (!gb->apu.square_channels[index].volume_countdown || !--gb->apu.square_channels[index].volume_countdown) {
+            if ((nrx2 & 8) && gb->apu.square_channels[index].current_volume < 0xF) {
+                gb->apu.square_channels[index].current_volume++;
+            }
+
+            else if (!(nrx2 & 8) && gb->apu.square_channels[index].current_volume > 0) {
+                gb->apu.square_channels[index].current_volume--;
+            }
+
+            gb->apu.square_channels[index].volume_countdown = nrx2 & 7;
+
+            if (gb->apu.is_active[index]) {
+                update_square_sample(gb, index);
+            }
+        }
+    }
+}
+
+static void tick_noise_envelope(GB_gameboy_t *gb)
+{
+    uint8_t nr42 = gb->io_registers[GB_IO_NR42];
+
+    if (gb->apu.noise_channel.volume_countdown || (nr42 & 7)) {
+        if (!--gb->apu.noise_channel.volume_countdown) {
+            if ((nr42 & 8) && gb->apu.noise_channel.current_volume < 0xF) {
+                gb->apu.noise_channel.current_volume++;
+            }
+
+            else if (!(nr42 & 8) && gb->apu.noise_channel.current_volume > 0) {
+                gb->apu.noise_channel.current_volume--;
+            }
+
+            gb->apu.noise_channel.volume_countdown = nr42 & 7;
+
+            if (gb->apu.is_active[GB_NOISE]) {
+                update_sample(gb, GB_NOISE,
+                              (gb->apu.noise_channel.lfsr & 1) ?
+                              gb->apu.noise_channel.current_volume : 0,
+                              0);
+            }
+        }
+    }
+}
+
+void GB_apu_div_event(GB_gameboy_t *gb)
+{
+    if (!gb->apu.global_enable) return;
+    if (gb->apu.skip_div_event) {
+        gb->apu.skip_div_event = false;
+        return;
+    }
+    gb->apu.div_divider++;
+
+    if ((gb->apu.div_divider & 1) == 0) {
+        for (unsigned i = GB_SQUARE_2 + 1; i--;) {
+            uint8_t nrx2 = gb->io_registers[i == GB_SQUARE_1? GB_IO_NR12 : GB_IO_NR22];
+            if (gb->apu.is_active[i] && gb->apu.square_channels[i].volume_countdown == 0 && (nrx2 & 7)) {
+                tick_square_envelope(gb, i);
+            }
+        }
+
+        if (gb->apu.is_active[GB_NOISE] && gb->apu.noise_channel.volume_countdown == 0 && (gb->io_registers[GB_IO_NR42] & 7)) {
+            tick_noise_envelope(gb);
+        }
+    }
+
+    if ((gb->apu.div_divider & 7) == 0) {
+        for (unsigned i = GB_SQUARE_2 + 1; i--;) {
+            tick_square_envelope(gb, i);
+        }
+
+        tick_noise_envelope(gb);
+    }
+
+    if ((gb->apu.div_divider & 1) == 1) {
+        for (unsigned i = GB_SQUARE_2 + 1; i--;) {
+            if (gb->apu.square_channels[i].length_enabled) {
+                if (gb->apu.square_channels[i].pulse_length) {
+                    if (!--gb->apu.square_channels[i].pulse_length) {
+                        gb->apu.is_active[i] = false;
+                        update_sample(gb, i, 0, 0);
+                    }
+                }
+            }
+        }
+
+        if (gb->apu.wave_channel.length_enabled) {
+            if (gb->apu.wave_channel.pulse_length) {
+                if (!--gb->apu.wave_channel.pulse_length) {
+                    gb->apu.is_active[GB_WAVE] = false;
+                    update_sample(gb, GB_WAVE, 0, 0);
+                }
+            }
+        }
+
+        if (gb->apu.noise_channel.length_enabled) {
+            if (gb->apu.noise_channel.pulse_length) {
+                if (!--gb->apu.noise_channel.pulse_length) {
+                    gb->apu.is_active[GB_NOISE] = false;
+                    update_sample(gb, GB_NOISE, 0, 0);
+                }
+            }
+        }
+    }
+
+    if ((gb->apu.div_divider & 3) == 3) {
+        if (!gb->apu.sweep_enabled) {
+            return;
+        }
+        if (gb->apu.square_sweep_countdown) {
+            if (!--gb->apu.square_sweep_countdown) {
+                if ((gb->io_registers[GB_IO_NR10] & 0x70) && (gb->io_registers[GB_IO_NR10] & 0x07)) {
+                    gb->apu.square_channels[GB_SQUARE_1].sample_length =
+                        gb->apu.shadow_sweep_sample_legnth =
+                        gb->apu.new_sweep_sample_legnth;
+                }
+
+                if (gb->io_registers[GB_IO_NR10] & 0x70) {
+                    /* Recalculation and overflow check only occurs after a delay */
+                    gb->apu.square_sweep_calculate_countdown = 0x13 - gb->apu.lf_div;
+                }
+
+                gb->apu.square_sweep_countdown = ((gb->io_registers[GB_IO_NR10] >> 4) & 7);
+                if (!gb->apu.square_sweep_countdown) gb->apu.square_sweep_countdown = 8;
+            }
+        }
+    }
+}
+
+
+void GB_apu_run(GB_gameboy_t *gb)
+{
+    /* Convert 4MHZ to 2MHz. apu_cycles is always divisable by 4. */
+    uint8_t cycles = gb->apu.apu_cycles >> 2;
+    gb->apu.apu_cycles = 0;
+    if (!cycles) return;
+    
+    if (likely(!gb->stopped || GB_is_cgb(gb))) {
+        /* To align the square signal to 1MHz */
+        gb->apu.lf_div ^= cycles & 1;
+        gb->apu.noise_channel.alignment += cycles;
+
+        if (gb->apu.square_sweep_calculate_countdown) {
+            if (gb->apu.square_sweep_calculate_countdown > cycles) {
+                gb->apu.square_sweep_calculate_countdown -= cycles;
+            }
+            else {
+                /* APU bug: sweep frequency is checked after adding the sweep delta twice */
+                gb->apu.new_sweep_sample_legnth = new_sweep_sample_legnth(gb);
+                if (gb->apu.new_sweep_sample_legnth > 0x7ff) {
+                    gb->apu.is_active[GB_SQUARE_1] = false;
+                    update_sample(gb, GB_SQUARE_1, 0, gb->apu.square_sweep_calculate_countdown - cycles);
+                    gb->apu.sweep_enabled = false;
+                }
+                gb->apu.sweep_decreasing |= gb->io_registers[GB_IO_NR10] & 8;
+                gb->apu.square_sweep_calculate_countdown = 0;
+            }
+        }
+
+        UNROLL
+        for (unsigned i = GB_SQUARE_1; i <= GB_SQUARE_2; i++) {
+            if (gb->apu.is_active[i]) {
+                uint8_t cycles_left = cycles;
+                while (unlikely(cycles_left > gb->apu.square_channels[i].sample_countdown)) {
+                    cycles_left -= gb->apu.square_channels[i].sample_countdown + 1;
+                    gb->apu.square_channels[i].sample_countdown = (gb->apu.square_channels[i].sample_length ^ 0x7FF) * 2 + 1;
+                    gb->apu.square_channels[i].current_sample_index++;
+                    gb->apu.square_channels[i].current_sample_index &= 0x7;
+
+                    update_square_sample(gb, i);
+                }
+                if (cycles_left) {
+                    gb->apu.square_channels[i].sample_countdown -= cycles_left;
+                }
+            }
+        }
+
+        gb->apu.wave_channel.wave_form_just_read = false;
+        if (gb->apu.is_active[GB_WAVE]) {
+            uint8_t cycles_left = cycles;
+            while (unlikely(cycles_left > gb->apu.wave_channel.sample_countdown)) {
+                cycles_left -= gb->apu.wave_channel.sample_countdown + 1;
+                gb->apu.wave_channel.sample_countdown = gb->apu.wave_channel.sample_length ^ 0x7FF;
+                gb->apu.wave_channel.current_sample_index++;
+                gb->apu.wave_channel.current_sample_index &= 0x1F;
+                gb->apu.wave_channel.current_sample =
+                    gb->apu.wave_channel.wave_form[gb->apu.wave_channel.current_sample_index];
+                update_sample(gb, GB_WAVE,
+                              gb->apu.wave_channel.current_sample >> gb->apu.wave_channel.shift,
+                              cycles - cycles_left);
+                gb->apu.wave_channel.wave_form_just_read = true;
+            }
+            if (cycles_left) {
+                gb->apu.wave_channel.sample_countdown -= cycles_left;
+                gb->apu.wave_channel.wave_form_just_read = false;
+            }
+        }
+
+        if (gb->apu.is_active[GB_NOISE]) {
+            uint8_t cycles_left = cycles;
+            while (unlikely(cycles_left > gb->apu.noise_channel.sample_countdown)) {
+                cycles_left -= gb->apu.noise_channel.sample_countdown + 1;
+                gb->apu.noise_channel.sample_countdown = gb->apu.noise_channel.sample_length * 4 + 3;
+
+                /* Step LFSR */
+                unsigned high_bit_mask = gb->apu.noise_channel.narrow ? 0x4040 : 0x4000;
+                /* Todo: is this formula is different on a GBA? */
+                bool new_high_bit = (gb->apu.noise_channel.lfsr ^ (gb->apu.noise_channel.lfsr >> 1) ^ 1) & 1;
+                gb->apu.noise_channel.lfsr >>= 1;
+
+                if (new_high_bit) {
+                    gb->apu.noise_channel.lfsr |= high_bit_mask;
+                }
+                else {
+                    /* This code is not redundent, it's relevant when switching LFSR widths */
+                    gb->apu.noise_channel.lfsr &= ~high_bit_mask;
+                }
+
+                gb->apu.current_lfsr_sample = gb->apu.noise_channel.lfsr & 1;
+
+                update_sample(gb, GB_NOISE,
+                              gb->apu.current_lfsr_sample ?
+                              gb->apu.noise_channel.current_volume : 0,
+                              0);
+            }
+            if (cycles_left) {
+                gb->apu.noise_channel.sample_countdown -= cycles_left;
+            }
+        }
+    }
+
+    if (gb->apu_output.sample_rate) {
+        gb->apu_output.cycles_since_render += cycles;
+
+        if (gb->apu_output.sample_cycles >= gb->apu_output.cycles_per_sample) {
+            gb->apu_output.sample_cycles -= gb->apu_output.cycles_per_sample;
+            render(gb);
+        }
+    }
+}
+void GB_apu_init(GB_gameboy_t *gb)
+{
+    memset(&gb->apu, 0, sizeof(gb->apu));
+    /* Restore the wave form */
+    for (unsigned reg = GB_IO_WAV_START; reg <= GB_IO_WAV_END; reg++) {
+        gb->apu.wave_channel.wave_form[(reg - GB_IO_WAV_START) * 2]     = gb->io_registers[reg] >> 4;
+        gb->apu.wave_channel.wave_form[(reg - GB_IO_WAV_START) * 2 + 1] = gb->io_registers[reg] & 0xF;
+    }
+    gb->apu.lf_div = 1;
+    /* APU glitch: When turning the APU on while DIV's bit 4 (or 5 in double speed mode) is on,
+       the first DIV/APU event is skipped. */
+    if (gb->div_counter & (gb->cgb_double_speed? 0x2000 : 0x1000)) {
+        gb->apu.skip_div_event = true;
+    }
+}
+
+uint8_t GB_apu_read(GB_gameboy_t *gb, uint8_t reg)
+{
+    if (reg == GB_IO_NR52) {
+        uint8_t value = 0;
+        for (int i = 0; i < GB_N_CHANNELS; i++) {
+            value >>= 1;
+            if (gb->apu.is_active[i]) {
+                value |= 0x8;
+            }
+        }
+        if (gb->apu.global_enable) {
+            value |= 0x80;
+        }
+        value |= 0x70;
+        return value;
+    }
+
+    static const char read_mask[GB_IO_WAV_END - GB_IO_NR10 + 1] = {
+     /* NRX0  NRX1  NRX2  NRX3  NRX4 */
+        0x80, 0x3F, 0x00, 0xFF, 0xBF, // NR1X
+        0xFF, 0x3F, 0x00, 0xFF, 0xBF, // NR2X
+        0x7F, 0xFF, 0x9F, 0xFF, 0xBF, // NR3X
+        0xFF, 0xFF, 0x00, 0x00, 0xBF, // NR4X
+        0x00, 0x00, 0x70, 0xFF, 0xFF, // NR5X
+
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // Unused
+        // Wave RAM
+        0, /* ... */
+    };
+
+    if (reg >= GB_IO_WAV_START && reg <= GB_IO_WAV_END && gb->apu.is_active[GB_WAVE]) {
+        if (!GB_is_cgb(gb) && !gb->apu.wave_channel.wave_form_just_read) {
+            return 0xFF;
+        }
+        reg = GB_IO_WAV_START + gb->apu.wave_channel.current_sample_index / 2;
+    }
+
+    return gb->io_registers[reg] | read_mask[reg - GB_IO_NR10];
+}
+
+void GB_apu_write(GB_gameboy_t *gb, uint8_t reg, uint8_t value)
+{
+    if (!gb->apu.global_enable && reg != GB_IO_NR52 && reg < GB_IO_WAV_START && (GB_is_cgb(gb) ||
+                                                                                (
+                                                                                reg != GB_IO_NR11 &&
+                                                                                reg != GB_IO_NR21 &&
+                                                                                reg != GB_IO_NR31 &&
+                                                                                reg != GB_IO_NR41
+                                                                                )
+                                                                                )) {
+        return;
+    }
+
+    if (reg >= GB_IO_WAV_START && reg <= GB_IO_WAV_END && gb->apu.is_active[GB_WAVE]) {
+        if (!GB_is_cgb(gb) && !gb->apu.wave_channel.wave_form_just_read) {
+            return;
+        }
+        reg = GB_IO_WAV_START + gb->apu.wave_channel.current_sample_index / 2;
+    }
+
+    /* Todo: this can and should be rewritten with a function table. */
+    switch (reg) {
+        /* Globals */
+        case GB_IO_NR50:
+        case GB_IO_NR51:
+            gb->io_registers[reg] = value;
+            /* These registers affect the output of all 4 channels (but not the output of the PCM registers).*/
+            /* We call update_samples with the current value so the APU output is updated with the new outputs */
+            for (unsigned i = GB_N_CHANNELS; i--;) {
+                update_sample(gb, i, gb->apu.samples[i], 0);
+            }
+            break;
+        case GB_IO_NR52: {
+
+            uint8_t old_nrx1[] = {
+                gb->io_registers[GB_IO_NR11],
+                gb->io_registers[GB_IO_NR21],
+                gb->io_registers[GB_IO_NR31],
+                gb->io_registers[GB_IO_NR41]
+            };
+            if ((value & 0x80) && !gb->apu.global_enable) {
+                GB_apu_init(gb);
+                gb->apu.global_enable = true;
+            }
+            else if (!(value & 0x80) && gb->apu.global_enable)  {
+                for (unsigned i = GB_N_CHANNELS; i--;) {
+                    update_sample(gb, i, 0, 0);
+                }
+                memset(&gb->apu, 0, sizeof(gb->apu));
+                memset(gb->io_registers + GB_IO_NR10, 0, GB_IO_WAV_START - GB_IO_NR10);
+                old_nrx1[0] &= 0x3F;
+                old_nrx1[1] &= 0x3F;
+
+                gb->apu.global_enable = false;
+            }
+
+            if (!GB_is_cgb(gb) && (value & 0x80)) {
+                GB_apu_write(gb, GB_IO_NR11, old_nrx1[0]);
+                GB_apu_write(gb, GB_IO_NR21, old_nrx1[1]);
+                GB_apu_write(gb, GB_IO_NR31, old_nrx1[2]);
+                GB_apu_write(gb, GB_IO_NR41, old_nrx1[3]);
+            }
+        }
+        break;
+
+        /* Square channels */
+        case GB_IO_NR10:
+            if (gb->apu.sweep_decreasing && !(value & 8)) {
+                gb->apu.is_active[GB_SQUARE_1] = false;
+                update_sample(gb, GB_SQUARE_1, 0, 0);
+                gb->apu.sweep_enabled = false;
+                gb->apu.square_sweep_calculate_countdown = 0;
+            }
+            if ((value & 0x70) == 0) {
+                /* Todo: what happens if we set period to 0 while a calculate event is scheduled, and then
+                         re-set it to non-zero? */
+                gb->apu.square_sweep_calculate_countdown = 0;
+            }
+            break;
+
+        case GB_IO_NR11:
+        case GB_IO_NR21: {
+            unsigned index = reg == GB_IO_NR21? GB_SQUARE_2: GB_SQUARE_1;
+            gb->apu.square_channels[index].pulse_length = (0x40 - (value & 0x3f));
+            if (!gb->apu.global_enable) {
+                value &= 0x3f;
+            }
+            break;
+        }
+
+        case GB_IO_NR12:
+        case GB_IO_NR22: {
+            unsigned index = reg == GB_IO_NR22? GB_SQUARE_2: GB_SQUARE_1;
+            if (((value & 0x7) == 0) && ((gb->io_registers[reg] & 0x7) != 0)) {
+                /* Envelope disabled */
+                gb->apu.square_channels[index].volume_countdown = 0;
+            }
+            if ((value & 0xF8) == 0) {
+                /* This disables the DAC */
+                gb->io_registers[reg] = value;
+                gb->apu.is_active[index] = false;
+                update_sample(gb, index, 0, 0);
+            }
+            else if (gb->apu.is_active[index]) {
+                nrx2_glitch(&gb->apu.square_channels[index].current_volume, value, gb->io_registers[reg]);
+                update_square_sample(gb, index);
+            }
+
+            break;
+        }
+
+        case GB_IO_NR13:
+        case GB_IO_NR23: {
+            unsigned index = reg == GB_IO_NR23? GB_SQUARE_2: GB_SQUARE_1;
+            gb->apu.square_channels[index].sample_length &= ~0xFF;
+            gb->apu.square_channels[index].sample_length |= value & 0xFF;
+            break;
+        }
+
+        case GB_IO_NR14:
+        case GB_IO_NR24: {
+            unsigned index = reg == GB_IO_NR24? GB_SQUARE_2: GB_SQUARE_1;
+            gb->apu.square_channels[index].sample_length &= 0xFF;
+            gb->apu.square_channels[index].sample_length |= (value & 7) << 8;
+            if (index == GB_SQUARE_1) {
+                gb->apu.shadow_sweep_sample_legnth =
+                    gb->apu.new_sweep_sample_legnth =
+                    gb->apu.square_channels[0].sample_length;
+            }
+            if (value & 0x80) {
+                /* Current sample index remains unchanged when restarting channels 1 or 2. It is only reset by
+                   turning the APU off. */
+                if (!gb->apu.is_active[index]) {
+                    gb->apu.square_channels[index].sample_countdown = (gb->apu.square_channels[index].sample_length ^ 0x7FF) * 2 + 6 - gb->apu.lf_div;
+                }
+                else {
+                    /* Timing quirk: if already active, sound starts 2 (2MHz) ticks earlier.*/
+                    gb->apu.square_channels[index].sample_countdown = (gb->apu.square_channels[index].sample_length ^ 0x7FF) * 2 + 4 - gb->apu.lf_div;
+                }
+                gb->apu.square_channels[index].current_volume = gb->io_registers[index == GB_SQUARE_1 ? GB_IO_NR12 : GB_IO_NR22] >> 4;
+
+                /* The volume changes caused by NRX4 sound start take effect instantly (i.e. the effect the previously
+                   started sound). The playback itself is not instant which is why we don't update the sample for other
+                   cases. */
+                if (gb->apu.is_active[index]) {
+                    update_square_sample(gb, index);
+                }
+
+                gb->apu.square_channels[index].volume_countdown = gb->io_registers[index == GB_SQUARE_1 ? GB_IO_NR12 : GB_IO_NR22] & 7;
+
+                if ((gb->io_registers[index == GB_SQUARE_1 ? GB_IO_NR12 : GB_IO_NR22] & 0xF8) != 0 && !gb->apu.is_active[index]) {
+                    gb->apu.is_active[index] = true;
+                    update_sample(gb, index, 0, 0);
+                    /* We use the highest bit in current_sample_index to mark this sample is not actually playing yet, */
+                    gb->apu.square_channels[index].current_sample_index |= 0x80;
+                }
+                if (gb->apu.square_channels[index].pulse_length == 0) {
+                    gb->apu.square_channels[index].pulse_length = 0x40;
+                    gb->apu.square_channels[index].length_enabled = false;
+                }
+
+                if (index == GB_SQUARE_1) {
+                    gb->apu.sweep_decreasing = false;
+                    if (gb->io_registers[GB_IO_NR10] & 7) {
+                        /* APU bug: if shift is nonzero, overflow check also occurs on trigger */
+                        gb->apu.square_sweep_calculate_countdown = 0x13 - gb->apu.lf_div;
+                    }
+                    else {
+                        gb->apu.square_sweep_calculate_countdown = 0;
+                    }
+                    gb->apu.sweep_enabled = gb->io_registers[GB_IO_NR10] & 0x77;
+                    gb->apu.square_sweep_countdown = ((gb->io_registers[GB_IO_NR10] >> 4) & 7);
+                    if (!gb->apu.square_sweep_countdown) gb->apu.square_sweep_countdown = 8;
+                }
+
+            }
+
+            /* APU glitch - if length is enabled while the DIV-divider's LSB is 1, tick the length once. */
+            if ((value & 0x40) &&
+                !gb->apu.square_channels[index].length_enabled &&
+                (gb->apu.div_divider & 1) &&
+                gb->apu.square_channels[index].pulse_length) {
+                gb->apu.square_channels[index].pulse_length--;
+                if (gb->apu.square_channels[index].pulse_length == 0) {
+                    if (value & 0x80) {
+                        gb->apu.square_channels[index].pulse_length = 0x3F;
+                    }
+                    else {
+                        gb->apu.is_active[index] = false;
+                        update_sample(gb, index, 0, 0);
+                    }
+                }
+            }
+            gb->apu.square_channels[index].length_enabled = value & 0x40;
+            break;
+        }
+
+        /* Wave channel */
+        case GB_IO_NR30:
+            gb->apu.wave_channel.enable = value & 0x80;
+            if (!gb->apu.wave_channel.enable) {
+                gb->apu.is_active[GB_WAVE] = false;
+                update_sample(gb, GB_WAVE, 0, 0);
+            }
+            break;
+        case GB_IO_NR31:
+            gb->apu.wave_channel.pulse_length = (0x100 - value);
+            break;
+        case GB_IO_NR32:
+            gb->apu.wave_channel.shift = (uint8_t[]){4, 0, 1, 2}[(value >> 5) & 3];
+            if (gb->apu.is_active[GB_WAVE]) {
+                update_sample(gb, GB_WAVE, gb->apu.wave_channel.current_sample >> gb->apu.wave_channel.shift, 0);
+            }
+            break;
+        case GB_IO_NR33:
+            gb->apu.wave_channel.sample_length &= ~0xFF;
+            gb->apu.wave_channel.sample_length |= value & 0xFF;
+            break;
+        case GB_IO_NR34:
+            gb->apu.wave_channel.sample_length &= 0xFF;
+            gb->apu.wave_channel.sample_length |= (value & 7) << 8;
+            if ((value & 0x80)) {
+                /* DMG bug: wave RAM gets corrupted if the channel is retriggerred 1 cycle before the APU
+                            reads from it. */
+                if (!GB_is_cgb(gb) &&
+                    gb->apu.is_active[GB_WAVE] &&
+                    gb->apu.wave_channel.sample_countdown == 0 &&
+                    gb->apu.wave_channel.enable) {
+                    unsigned offset = ((gb->apu.wave_channel.current_sample_index + 1) >> 1) & 0xF;
+
+                    /* This glitch varies between models and even specific instances:
+                       DMG-B:     Most of them behave as emulated. A few behave differently.
+                       SGB:       As far as I know, all tested instances behave as emulated.
+                       MGB, SGB2: Most instances behave non-deterministically, a few behave as emulated.
+
+                      Additionally, I believe DMGs, including those we behave differently than emulated,
+                      are all deterministic. */
+                    if (offset < 4) {
+                        gb->io_registers[GB_IO_WAV_START] = gb->io_registers[GB_IO_WAV_START + offset];
+                        gb->apu.wave_channel.wave_form[0] = gb->apu.wave_channel.wave_form[offset / 2];
+                        gb->apu.wave_channel.wave_form[1] = gb->apu.wave_channel.wave_form[offset / 2 + 1];
+                    }
+                    else {
+                        memcpy(gb->io_registers + GB_IO_WAV_START,
+                               gb->io_registers + GB_IO_WAV_START + (offset & ~3),
+                               4);
+                        memcpy(gb->apu.wave_channel.wave_form,
+                               gb->apu.wave_channel.wave_form + (offset & ~3) * 2,
+                               8);
+                    }
+                }
+                if (!gb->apu.is_active[GB_WAVE]) {
+                    gb->apu.is_active[GB_WAVE] = true;
+                    update_sample(gb, GB_WAVE,
+                                  gb->apu.wave_channel.current_sample >> gb->apu.wave_channel.shift,
+                                  0);
+                }
+                gb->apu.wave_channel.sample_countdown = (gb->apu.wave_channel.sample_length ^ 0x7FF) + 3;
+                gb->apu.wave_channel.current_sample_index = 0;
+                if (gb->apu.wave_channel.pulse_length == 0) {
+                    gb->apu.wave_channel.pulse_length = 0x100;
+                    gb->apu.wave_channel.length_enabled = false;
+                }
+                /* Note that we don't change the sample just yet! This was verified on hardware. */
+            }
+
+            /* APU glitch - if length is enabled while the DIV-divider's LSB is 1, tick the length once. */
+            if ((value & 0x40) &&
+                !gb->apu.wave_channel.length_enabled &&
+                (gb->apu.div_divider & 1) &&
+                gb->apu.wave_channel.pulse_length) {
+                gb->apu.wave_channel.pulse_length--;
+                if (gb->apu.wave_channel.pulse_length == 0) {
+                    if (value & 0x80) {
+                        gb->apu.wave_channel.pulse_length = 0xFF;
+                    }
+                    else {
+                        gb->apu.is_active[GB_WAVE] = false;
+                        update_sample(gb, GB_WAVE, 0, 0);
+                    }
+                }
+            }
+            gb->apu.wave_channel.length_enabled = value & 0x40;
+            if (gb->apu.is_active[GB_WAVE] && !gb->apu.wave_channel.enable) {
+                gb->apu.is_active[GB_WAVE] = false;
+                update_sample(gb, GB_WAVE, 0, 0);
+            }
+
+            break;
+
+        /* Noise Channel */
+
+        case GB_IO_NR41: {
+            gb->apu.noise_channel.pulse_length = (0x40 - (value & 0x3f));
+            break;
+        }
+
+        case GB_IO_NR42: {
+            if (((value & 0x7) == 0) && ((gb->io_registers[reg] & 0x7) != 0)) {
+                /* Envelope disabled */
+                gb->apu.noise_channel.volume_countdown = 0;
+            }
+            if ((value & 0xF8) == 0) {
+                /* This disables the DAC */
+                gb->io_registers[reg] = value;
+                gb->apu.is_active[GB_NOISE] = false;
+                update_sample(gb, GB_NOISE, 0, 0);
+            }
+            else if (gb->apu.is_active[GB_NOISE]){
+                nrx2_glitch(&gb->apu.noise_channel.current_volume, value, gb->io_registers[reg]);
+                update_sample(gb, GB_NOISE,
+                              gb->apu.current_lfsr_sample ?
+                              gb->apu.noise_channel.current_volume : 0,
+                              0);
+            }
+            break;
+        }
+
+        case GB_IO_NR43: {
+            gb->apu.noise_channel.narrow = value & 8;
+            unsigned divisor = (value & 0x07) << 1;
+            if (!divisor) divisor = 1;
+            gb->apu.noise_channel.sample_length = (divisor << (value >> 4)) - 1;
+
+            /* Todo: changing the frequency sometimes delays the next sample. This is probably
+               due to how the frequency is actually calculated in the noise channel, which is probably
+               not by calculating the effective sample length and counting simiarly to the other channels.
+               This is not emulated correctly. */
+            break;
+        }
+
+        case GB_IO_NR44: {
+            if (value & 0x80) {
+                gb->apu.noise_channel.sample_countdown = (gb->apu.noise_channel.sample_length) * 2 + 6 - gb->apu.lf_div;
+
+                /* I'm COMPLETELY unsure about this logic, but it passes all relevant tests.
+                   See comment in NR43. */
+                if ((gb->io_registers[GB_IO_NR43] & 7) && (gb->apu.noise_channel.alignment & 2) == 0) {
+                    if ((gb->io_registers[GB_IO_NR43] & 7) == 1) {
+                        gb->apu.noise_channel.sample_countdown += 2;
+                    }
+                    else {
+                        gb->apu.noise_channel.sample_countdown -= 2;
+                    }
+                }
+                if (gb->apu.is_active[GB_NOISE]) {
+                    gb->apu.noise_channel.sample_countdown += 2;
+                }
+
+                gb->apu.noise_channel.current_volume = gb->io_registers[GB_IO_NR42] >> 4;
+
+                /* The volume changes caused by NRX4 sound start take effect instantly (i.e. the effect the previously
+                 started sound). The playback itself is not instant which is why we don't update the sample for other
+                 cases. */
+                if (gb->apu.is_active[GB_NOISE]) {
+                    update_sample(gb, GB_NOISE,
+                                  gb->apu.current_lfsr_sample ?
+                                  gb->apu.noise_channel.current_volume : 0,
+                                  0);
+                }
+                gb->apu.noise_channel.lfsr = 0;
+                gb->apu.current_lfsr_sample = false;
+                gb->apu.noise_channel.volume_countdown = gb->io_registers[GB_IO_NR42] & 7;
+
+                if (!gb->apu.is_active[GB_NOISE] && (gb->io_registers[GB_IO_NR42] & 0xF8) != 0) {
+                    gb->apu.is_active[GB_NOISE] = true;
+                    update_sample(gb, GB_NOISE, 0, 0);
+                }
+
+                if (gb->apu.noise_channel.pulse_length == 0) {
+                    gb->apu.noise_channel.pulse_length = 0x40;
+                    gb->apu.noise_channel.length_enabled = false;
+                }
+            }
+
+            /* APU glitch - if length is enabled while the DIV-divider's LSB is 1, tick the length once. */
+            if ((value & 0x40) &&
+                !gb->apu.noise_channel.length_enabled &&
+                (gb->apu.div_divider & 1) &&
+                gb->apu.noise_channel.pulse_length) {
+                gb->apu.noise_channel.pulse_length--;
+                if (gb->apu.noise_channel.pulse_length == 0) {
+                    if (value & 0x80) {
+                        gb->apu.noise_channel.pulse_length = 0x3F;
+                    }
+                    else {
+                        gb->apu.is_active[GB_NOISE] = false;
+                        update_sample(gb, GB_NOISE, 0, 0);
+                    }
+                }
+            }
+            gb->apu.noise_channel.length_enabled = value & 0x40;
+            break;
+        }
+
+        default:
+            if (reg >= GB_IO_WAV_START && reg <= GB_IO_WAV_END) {
+                gb->apu.wave_channel.wave_form[(reg - GB_IO_WAV_START) * 2]     = value >> 4;
+                gb->apu.wave_channel.wave_form[(reg - GB_IO_WAV_START) * 2 + 1] = value & 0xF;
+            }
+    }
+    gb->io_registers[reg] = value;
+}
+
+void GB_set_sample_rate(GB_gameboy_t *gb, unsigned sample_rate)
+{
+
+    gb->apu_output.sample_rate = sample_rate;
+    if (sample_rate) {
+        gb->apu_output.highpass_rate = pow(0.999958,  GB_get_clock_rate(gb) / (double)sample_rate);
+    }
+    GB_apu_update_cycles_per_sample(gb);
+}
+
+void GB_apu_set_sample_callback(GB_gameboy_t *gb, GB_sample_callback_t callback)
+{
+    gb->apu_output.sample_callback = callback;
+}
+
+void GB_set_highpass_filter_mode(GB_gameboy_t *gb, GB_highpass_mode_t mode)
+{
+    gb->apu_output.highpass_mode = mode;
+}
+
+void GB_apu_update_cycles_per_sample(GB_gameboy_t *gb)
+{
+    if (gb->apu_output.sample_rate) {
+        gb->apu_output.cycles_per_sample = 2 * GB_get_clock_rate(gb) / (double)gb->apu_output.sample_rate; /* 2 * because we use 8MHz units */
+    }
+}

bsnes/gb/Core/apu.h

@@ -0,0 +1,161 @@
+#ifndef apu_h
+#define apu_h
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+#include "gb_struct_def.h"
+
+
+#ifdef GB_INTERNAL
+/* Speed = 1 / Length (in seconds) */
+#define DAC_DECAY_SPEED 20000
+#define DAC_ATTACK_SPEED 20000
+
+
+/* Divides nicely and never overflows with 4 channels and 8 (1-8) volume levels */
+#ifdef WIIU
+/* Todo: Remove this hack once https://github.com/libretro/RetroArch/issues/6252 is fixed*/
+#define MAX_CH_AMP (0xFF0 / 2)
+#else
+#define MAX_CH_AMP 0xFF0
+#endif
+#define CH_STEP (MAX_CH_AMP/0xF/8)
+#endif
+
+
+
+/* APU ticks are 2MHz, triggered by an internal APU clock. */
+
+typedef struct
+{
+    int16_t left;
+    int16_t right;
+} GB_sample_t;
+
+typedef struct
+{
+    double left;
+    double right;
+} GB_double_sample_t;
+
+enum GB_CHANNELS {
+    GB_SQUARE_1,
+    GB_SQUARE_2,
+    GB_WAVE,
+    GB_NOISE,
+    GB_N_CHANNELS
+};
+
+typedef void (*GB_sample_callback_t)(GB_gameboy_t *gb, GB_sample_t *sample);
+
+typedef struct
+{
+    bool global_enable;
+    uint8_t apu_cycles;
+
+    uint8_t samples[GB_N_CHANNELS];
+    bool is_active[GB_N_CHANNELS];
+
+    uint8_t div_divider; // The DIV register ticks the APU at 512Hz, but is then divided
+                         // once more to generate 128Hz and 64Hz clocks
+
+    uint8_t lf_div; // The APU runs in 2MHz, but channels 1, 2 and 4 run in 1MHZ so we divide
+                    // need to divide the signal.
+
+    uint8_t square_sweep_countdown; // In 128Hz
+    uint8_t square_sweep_calculate_countdown; // In 2 MHz
+    uint16_t new_sweep_sample_legnth;
+    uint16_t shadow_sweep_sample_legnth;
+    bool sweep_enabled;
+    bool sweep_decreasing;
+
+    struct {
+        uint16_t pulse_length; // Reloaded from NRX1 (xorred), in 256Hz DIV ticks
+        uint8_t current_volume; // Reloaded from NRX2
+        uint8_t volume_countdown; // Reloaded from NRX2
+        uint8_t current_sample_index; /* For save state compatibility,
+                                         highest bit is reused (See NR14/NR24's
+                                         write code)*/
+
+        uint16_t sample_countdown; // in APU ticks (Reloaded from sample_length, xorred $7FF)
+        uint16_t sample_length; // From NRX3, NRX4, in APU ticks
+        bool length_enabled; // NRX4
+
+    } square_channels[2];
+
+    struct {
+        bool enable; // NR30
+        uint16_t pulse_length; // Reloaded from NR31 (xorred), in 256Hz DIV ticks
+        uint8_t shift; // NR32
+        uint16_t sample_length; // NR33, NR34, in APU ticks
+        bool length_enabled; // NR34
+
+        uint16_t sample_countdown; // in APU ticks (Reloaded from sample_length, xorred $7FF)
+        uint8_t current_sample_index;
+        uint8_t current_sample; // Current sample before shifting.
+
+        int8_t wave_form[32];
+        bool wave_form_just_read;
+    } wave_channel;
+
+    struct {
+        uint16_t pulse_length; // Reloaded from NR41 (xorred), in 256Hz DIV ticks
+        uint8_t current_volume; // Reloaded from NR42
+        uint8_t volume_countdown; // Reloaded from NR42
+        uint16_t lfsr;
+        bool narrow;
+
+        uint16_t sample_countdown; // in APU ticks (Reloaded from sample_length)
+        uint16_t sample_length; // From NR43, in APU ticks
+        bool length_enabled; // NR44
+
+        uint8_t alignment; // If (NR43 & 7) != 0, samples are aligned to 512KHz clock instead of
+                           // 1MHz. This variable keeps track of the alignment.
+
+    } noise_channel;
+
+    bool skip_div_event;
+    bool current_lfsr_sample;
+} GB_apu_t;
+
+typedef enum {
+    GB_HIGHPASS_OFF, // Do not apply any filter, keep DC offset
+    GB_HIGHPASS_ACCURATE, // Apply a highpass filter similar to the one used on hardware
+    GB_HIGHPASS_REMOVE_DC_OFFSET, // Remove DC Offset without affecting the waveform
+    GB_HIGHPASS_MAX
+} GB_highpass_mode_t;
+
+typedef struct {
+    unsigned sample_rate;
+
+    double sample_cycles; // In 8 MHz units
+    double cycles_per_sample;
+
+    // Samples are NOT normalized to MAX_CH_AMP * 4 at this stage!
+    unsigned cycles_since_render;
+    unsigned last_update[GB_N_CHANNELS];
+    GB_sample_t current_sample[GB_N_CHANNELS];
+    GB_sample_t summed_samples[GB_N_CHANNELS];
+    double dac_discharge[GB_N_CHANNELS];
+
+    GB_highpass_mode_t highpass_mode;
+    double highpass_rate;
+    GB_double_sample_t highpass_diff;
+    
+    GB_sample_callback_t sample_callback;
+} GB_apu_output_t;
+
+void GB_set_sample_rate(GB_gameboy_t *gb, unsigned sample_rate);
+void GB_set_highpass_filter_mode(GB_gameboy_t *gb, GB_highpass_mode_t mode);
+void GB_apu_set_sample_callback(GB_gameboy_t *gb, GB_sample_callback_t callback);
+#ifdef GB_INTERNAL
+bool GB_apu_is_DAC_enabled(GB_gameboy_t *gb, unsigned index);
+void GB_apu_write(GB_gameboy_t *gb, uint8_t reg, uint8_t value);
+uint8_t GB_apu_read(GB_gameboy_t *gb, uint8_t reg);
+void GB_apu_div_event(GB_gameboy_t *gb);
+void GB_apu_init(GB_gameboy_t *gb);
+void GB_apu_run(GB_gameboy_t *gb);
+void GB_apu_update_cycles_per_sample(GB_gameboy_t *gb);
+#endif
+
+#endif /* apu_h */

bsnes/gb/Core/camera.c

@@ -0,0 +1,149 @@
+#include "gb.h"
+
+static int noise_seed = 0;
+
+/* This is not a complete emulation of the camera chip. Only the features used by the GameBoy Camera ROMs are supported.
+    We also do not emulate the timing of the real cart, as it might be actually faster than the webcam. */
+
+static uint8_t generate_noise(uint8_t x, uint8_t y)
+{
+    int value = (x + y * 128 + noise_seed);
+    uint8_t *data = (uint8_t *) &value;
+    unsigned hash = 0;
+
+    while ((int *) data != &value + 1) {
+        hash ^= (*data << 8);
+        if (hash & 0x8000) {
+            hash ^= 0x8a00;
+            hash ^= *data;
+        }
+        data++;
+        hash <<= 1;
+    }
+    return (hash >> 8);
+}
+
+static long get_processed_color(GB_gameboy_t *gb, uint8_t x, uint8_t y)
+{
+    if (x >= 128) {
+        x = 0;
+    }
+    if (y >= 112) {
+        y = 0;
+    }
+
+    long color = gb->camera_get_pixel_callback? gb->camera_get_pixel_callback(gb, x, y) : (generate_noise(x, y));
+
+    static const double gain_values[] =
+        {0.8809390, 0.9149149, 0.9457498, 0.9739758,
+         1.0000000, 1.0241412, 1.0466537, 1.0677433,
+         1.0875793, 1.1240310, 1.1568911, 1.1868043,
+         1.2142561, 1.2396208, 1.2743837, 1.3157323,
+         1.3525190, 1.3856512, 1.4157897, 1.4434309,
+         1.4689574, 1.4926697, 1.5148087, 1.5355703,
+         1.5551159, 1.5735801, 1.5910762, 1.6077008,
+         1.6235366, 1.6386550, 1.6531183, 1.6669808};
+    /* Multiply color by gain value */
+    color *= gain_values[gb->camera_registers[GB_CAMERA_GAIN_AND_EDGE_ENHACEMENT_FLAGS] & 0x1F];
+
+
+    /* Color is multiplied by the exposure register to simulate exposure. */
+    color = color * ((gb->camera_registers[GB_CAMERA_EXPOSURE_HIGH] << 8) + gb->camera_registers[GB_CAMERA_EXPOSURE_LOW]) / 0x1000;
+
+    return color;
+}
+
+uint8_t GB_camera_read_image(GB_gameboy_t *gb, uint16_t addr)
+{
+    if (gb->camera_registers[GB_CAMERA_SHOOT_AND_1D_FLAGS] & 1) {
+        /* Forbid reading the image while the camera is busy. */
+        return 0xFF;
+    }
+    uint8_t tile_x = addr / 0x10 % 0x10;
+    uint8_t tile_y = addr / 0x10 / 0x10;
+
+    uint8_t y = ((addr >> 1) & 0x7) + tile_y * 8;
+    uint8_t bit = addr & 1;
+
+    uint8_t ret = 0;
+
+    for (uint8_t x = tile_x * 8; x < tile_x * 8 + 8; x++) {
+
+        long color = get_processed_color(gb, x, y);
+
+        static const double edge_enhancement_ratios[] = {0.5, 0.75, 1, 1.25, 2, 3, 4, 5};
+        double edge_enhancement_ratio = edge_enhancement_ratios[(gb->camera_registers[GB_CAMERA_EDGE_ENHANCEMENT_INVERT_AND_VOLTAGE] >> 4) & 0x7];
+        if ((gb->camera_registers[GB_CAMERA_GAIN_AND_EDGE_ENHACEMENT_FLAGS] & 0xE0) == 0xE0) {
+                color += (color * 4) * edge_enhancement_ratio;
+                color -= get_processed_color(gb, x - 1, y) * edge_enhancement_ratio;
+                color -= get_processed_color(gb, x + 1, y) * edge_enhancement_ratio;
+                color -= get_processed_color(gb, x, y - 1) * edge_enhancement_ratio;
+                color -= get_processed_color(gb, x, y + 1) * edge_enhancement_ratio;
+        }
+
+
+        /* The camera's registers are used as a threshold pattern, which defines the dithering */
+        uint8_t pattern_base = ((x & 3) + (y & 3) * 4) * 3 + GB_CAMERA_DITHERING_PATTERN_START;
+
+        if (color < gb->camera_registers[pattern_base]) {
+            color = 3;
+        }
+        else if (color < gb->camera_registers[pattern_base + 1]) {
+            color = 2;
+        }
+        else if (color < gb->camera_registers[pattern_base + 2]) {
+            color = 1;
+        }
+        else {
+            color = 0;
+        }
+
+        ret <<= 1;
+        ret |= (color >> bit) & 1;
+    }
+
+    return ret;
+}
+
+void GB_set_camera_get_pixel_callback(GB_gameboy_t *gb, GB_camera_get_pixel_callback_t callback)
+{
+    gb->camera_get_pixel_callback = callback;
+}
+
+void GB_set_camera_update_request_callback(GB_gameboy_t *gb, GB_camera_update_request_callback_t callback)
+{
+    gb->camera_update_request_callback = callback;
+}
+
+void GB_camera_updated(GB_gameboy_t *gb)
+{
+    gb->camera_registers[GB_CAMERA_SHOOT_AND_1D_FLAGS] &= ~1;
+}
+
+void GB_camera_write_register(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+    addr &= 0x7F;
+    if (addr == GB_CAMERA_SHOOT_AND_1D_FLAGS) {
+        value &= 0x7;
+        noise_seed = rand();
+        if ((value & 1) && !(gb->camera_registers[GB_CAMERA_SHOOT_AND_1D_FLAGS] & 1) && gb->camera_update_request_callback) {
+            /* If no callback is set, ignore the write as if the camera is instantly done */
+            gb->camera_registers[GB_CAMERA_SHOOT_AND_1D_FLAGS] |= 1;
+            gb->camera_update_request_callback(gb);
+        }
+    }
+    else {
+        if (addr >= 0x36) {
+            GB_log(gb, "Wrote invalid camera register %02x: %2x\n", addr, value);
+            return;
+        }
+        gb->camera_registers[addr] = value;
+    }
+}
+uint8_t GB_camera_read_register(GB_gameboy_t *gb, uint16_t addr)
+{
+    if ((addr & 0x7F) == 0) {
+        return gb->camera_registers[GB_CAMERA_SHOOT_AND_1D_FLAGS];
+    }
+    return 0;
+}

bsnes/gb/Core/camera.h

@@ -0,0 +1,29 @@
+#ifndef camera_h
+#define camera_h
+#include <stdint.h>
+#include "gb_struct_def.h"
+
+typedef uint8_t (*GB_camera_get_pixel_callback_t)(GB_gameboy_t *gb, uint8_t x, uint8_t y);
+typedef void (*GB_camera_update_request_callback_t)(GB_gameboy_t *gb);
+
+enum {
+    GB_CAMERA_SHOOT_AND_1D_FLAGS = 0,
+    GB_CAMERA_GAIN_AND_EDGE_ENHACEMENT_FLAGS = 1,
+    GB_CAMERA_EXPOSURE_HIGH = 2,
+    GB_CAMERA_EXPOSURE_LOW = 3,
+    GB_CAMERA_EDGE_ENHANCEMENT_INVERT_AND_VOLTAGE = 4,
+    GB_CAMERA_DITHERING_PATTERN_START = 6,
+    GB_CAMERA_DITHERING_PATTERN_END = 0x35,
+};
+
+uint8_t GB_camera_read_image(GB_gameboy_t *gb, uint16_t addr);
+
+void GB_set_camera_get_pixel_callback(GB_gameboy_t *gb, GB_camera_get_pixel_callback_t callback);
+void GB_set_camera_update_request_callback(GB_gameboy_t *gb, GB_camera_update_request_callback_t callback);
+
+void GB_camera_updated(GB_gameboy_t *gb);
+
+void GB_camera_write_register(GB_gameboy_t *gb, uint16_t addr, uint8_t value);
+uint8_t GB_camera_read_register(GB_gameboy_t *gb, uint16_t addr);
+
+#endif

bsnes/gb/Core/debugger.h

@@ -0,0 +1,43 @@
+#ifndef debugger_h
+#define debugger_h
+#include <stdbool.h>
+#include <stdint.h>
+#include "gb_struct_def.h"
+#include "symbol_hash.h"
+
+
+#ifdef GB_INTERNAL
+#ifdef DISABLE_DEBUGGER
+#define GB_debugger_run(gb) (void)0
+#define GB_debugger_handle_async_commands(gb) (void)0
+#define GB_debugger_ret_hook(gb) (void)0
+#define GB_debugger_call_hook(gb, addr) (void)addr
+#define GB_debugger_test_write_watchpoint(gb, addr, value) ((void)addr, (void)value)
+#define GB_debugger_test_read_watchpoint(gb, addr) (void)addr
+#else
+void GB_debugger_run(GB_gameboy_t *gb);
+void GB_debugger_handle_async_commands(GB_gameboy_t *gb);
+void GB_debugger_call_hook(GB_gameboy_t *gb, uint16_t call_addr);
+void GB_debugger_ret_hook(GB_gameboy_t *gb);
+void GB_debugger_test_write_watchpoint(GB_gameboy_t *gb, uint16_t addr, uint8_t value);
+void GB_debugger_test_read_watchpoint(GB_gameboy_t *gb, uint16_t addr);
+const GB_bank_symbol_t *GB_debugger_find_symbol(GB_gameboy_t *gb, uint16_t addr);
+#endif /* DISABLE_DEBUGGER */
+#endif
+
+#ifdef GB_INTERNAL
+bool /* Returns true if debugger waits for more commands. Not relevant for non-GB_INTERNAL */
+#else
+void
+#endif
+GB_debugger_execute_command(GB_gameboy_t *gb, char *input); /* Destroys input. */
+
+
+void GB_debugger_load_symbol_file(GB_gameboy_t *gb, const char *path);
+const char *GB_debugger_name_for_address(GB_gameboy_t *gb, uint16_t addr);
+bool GB_debugger_evaluate(GB_gameboy_t *gb, const char *string, uint16_t *result, uint16_t *result_bank); /* result_bank is -1 if unused. */
+void GB_debugger_break(GB_gameboy_t *gb);
+bool GB_debugger_is_stopped(GB_gameboy_t *gb);
+void GB_debugger_set_disabled(GB_gameboy_t *gb, bool disabled);
+void GB_debugger_clear_symbols(GB_gameboy_t *gb);
+#endif /* debugger_h */

bsnes/gb/Core/display.h

@@ -0,0 +1,54 @@
+#ifndef display_h
+#define display_h
+
+#include "gb.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef GB_INTERNAL
+void GB_display_run(GB_gameboy_t *gb, uint8_t cycles);
+void GB_palette_changed(GB_gameboy_t *gb, bool background_palette, uint8_t index);
+void GB_window_related_write(GB_gameboy_t *gb, uint8_t addr, uint8_t value);
+void GB_STAT_update(GB_gameboy_t *gb);
+void GB_lcd_off(GB_gameboy_t *gb);
+#endif
+
+typedef enum {
+    GB_PALETTE_NONE,
+    GB_PALETTE_BACKGROUND,
+    GB_PALETTE_OAM,
+    GB_PALETTE_AUTO,
+} GB_palette_type_t;
+
+typedef enum {
+    GB_MAP_AUTO,
+    GB_MAP_9800,
+    GB_MAP_9C00,
+} GB_map_type_t;
+
+typedef enum {
+    GB_TILESET_AUTO,
+    GB_TILESET_8800,
+    GB_TILESET_8000,
+} GB_tileset_type_t;
+
+typedef struct {
+    uint32_t image[128];
+    uint8_t x, y, tile, flags;
+    uint16_t oam_addr;
+    bool obscured_by_line_limit;
+} GB_oam_info_t;
+
+typedef enum {
+    GB_COLOR_CORRECTION_DISABLED,
+    GB_COLOR_CORRECTION_CORRECT_CURVES,
+    GB_COLOR_CORRECTION_EMULATE_HARDWARE,
+    GB_COLOR_CORRECTION_PRESERVE_BRIGHTNESS,
+} GB_color_correction_mode_t;
+
+void GB_draw_tileset(GB_gameboy_t *gb, uint32_t *dest, GB_palette_type_t palette_type, uint8_t palette_index);
+void GB_draw_tilemap(GB_gameboy_t *gb, uint32_t *dest, GB_palette_type_t palette_type, uint8_t palette_index, GB_map_type_t map_type, GB_tileset_type_t tileset_type);
+uint8_t GB_get_oam_info(GB_gameboy_t *gb, GB_oam_info_t *dest, uint8_t *sprite_height);
+uint32_t GB_convert_rgb15(GB_gameboy_t *gb, uint16_t color);
+void GB_set_color_correction_mode(GB_gameboy_t *gb, GB_color_correction_mode_t mode);
+#endif /* display_h */

bsnes/gb/Core/gb.h

@@ -0,0 +1,727 @@
+#ifndef GB_h
+#define GB_h
+#define typeof __typeof__
+#define _XOPEN_SOURCE 500
+#include <stdbool.h>
+#include <stdint.h>
+#include <time.h>
+
+#include "gb_struct_def.h"
+#include "save_state.h"
+
+#include "apu.h"
+#include "camera.h"
+#include "debugger.h"
+#include "display.h"
+#include "joypad.h"
+#include "mbc.h"
+#include "memory.h"
+#include "printer.h"
+#include "timing.h"
+#include "rewind.h"
+#include "sm83_cpu.h"
+#include "symbol_hash.h"
+#include "sgb.h"
+
+#define GB_STRUCT_VERSION 13
+
+#define GB_MODEL_FAMILY_MASK 0xF00
+#define GB_MODEL_DMG_FAMILY 0x000
+#define GB_MODEL_MGB_FAMILY 0x100
+#define GB_MODEL_CGB_FAMILY 0x200
+#define GB_MODEL_PAL_BIT 0x1000
+#define GB_MODEL_NO_SFC_BIT 0x2000
+
+#ifdef GB_INTERNAL
+#if __clang__
+#define UNROLL _Pragma("unroll")
+#elif __GNUC__
+#define UNROLL _Pragma("GCC unroll 8")
+#else
+#define UNROLL
+#endif
+
+#endif
+
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define GB_BIG_ENDIAN
+#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define GB_LITTLE_ENDIAN
+#else
+#error Unable to detect endianess
+#endif
+
+typedef union {
+    struct {
+        uint8_t seconds;
+        uint8_t minutes;
+        uint8_t hours;
+        uint8_t days;
+        uint8_t high;
+    };
+    uint8_t data[5];
+} GB_rtc_time_t;
+
+
+typedef enum {
+    // GB_MODEL_DMG_0 = 0x000,
+    // GB_MODEL_DMG_A = 0x001,
+    GB_MODEL_DMG_B = 0x002,
+    // GB_MODEL_DMG_C = 0x003,
+    GB_MODEL_SGB = 0x004,
+    GB_MODEL_SGB_NTSC = GB_MODEL_SGB,
+    GB_MODEL_SGB_PAL = GB_MODEL_SGB | GB_MODEL_PAL_BIT,
+    GB_MODEL_SGB_NO_SFC = GB_MODEL_SGB | GB_MODEL_NO_SFC_BIT,
+    // GB_MODEL_MGB = 0x100,
+    GB_MODEL_SGB2 = 0x101,
+    GB_MODEL_SGB2_NO_SFC = GB_MODEL_SGB2 | GB_MODEL_NO_SFC_BIT,
+    // GB_MODEL_CGB_0 = 0x200,
+    // GB_MODEL_CGB_A = 0x201,
+    // GB_MODEL_CGB_B = 0x202,
+    GB_MODEL_CGB_C = 0x203,
+    // GB_MODEL_CGB_D = 0x204,
+    GB_MODEL_CGB_E = 0x205,
+    GB_MODEL_AGB = 0x206,
+} GB_model_t;
+
+enum {
+    GB_REGISTER_AF,
+    GB_REGISTER_BC,
+    GB_REGISTER_DE,
+    GB_REGISTER_HL,
+    GB_REGISTER_SP,
+    GB_REGISTERS_16_BIT /* Count */
+};
+
+/* Todo: Actually use these! */
+enum {
+    GB_CARRY_FLAG = 16,
+    GB_HALF_CARRY_FLAG = 32,
+    GB_SUBSTRACT_FLAG = 64,
+    GB_ZERO_FLAG = 128,
+};
+
+#define GB_MAX_IR_QUEUE 256
+
+enum {
+    /* Joypad and Serial */
+    GB_IO_JOYP       = 0x00, // Joypad (R/W)
+    GB_IO_SB         = 0x01, // Serial transfer data (R/W)
+    GB_IO_SC         = 0x02, // Serial Transfer Control (R/W)
+
+    /* Missing */
+
+    /* Timers */
+    GB_IO_DIV        = 0x04, // Divider Register (R/W)
+    GB_IO_TIMA       = 0x05, // Timer counter (R/W)
+    GB_IO_TMA        = 0x06, // Timer Modulo (R/W)
+    GB_IO_TAC        = 0x07, // Timer Control (R/W)
+
+    /* Missing */
+
+    GB_IO_IF         = 0x0f, // Interrupt Flag (R/W)
+
+    /* Sound */
+    GB_IO_NR10       = 0x10, // Channel 1 Sweep register (R/W)
+    GB_IO_NR11       = 0x11, // Channel 1 Sound length/Wave pattern duty (R/W)
+    GB_IO_NR12       = 0x12, // Channel 1 Volume Envelope (R/W)
+    GB_IO_NR13       = 0x13, // Channel 1 Frequency lo (Write Only)
+    GB_IO_NR14       = 0x14, // Channel 1 Frequency hi (R/W)
+    /* NR20 does not exist */
+    GB_IO_NR21       = 0x16, // Channel 2 Sound Length/Wave Pattern Duty (R/W)
+    GB_IO_NR22       = 0x17, // Channel 2 Volume Envelope (R/W)
+    GB_IO_NR23       = 0x18, // Channel 2 Frequency lo data (W)
+    GB_IO_NR24       = 0x19, // Channel 2 Frequency hi data (R/W)
+    GB_IO_NR30       = 0x1a, // Channel 3 Sound on/off (R/W)
+    GB_IO_NR31       = 0x1b, // Channel 3 Sound Length
+    GB_IO_NR32       = 0x1c, // Channel 3 Select output level (R/W)
+    GB_IO_NR33       = 0x1d, // Channel 3 Frequency's lower data (W)
+    GB_IO_NR34       = 0x1e, // Channel 3 Frequency's higher data (R/W)
+    /* NR40 does not exist */
+    GB_IO_NR41       = 0x20, // Channel 4 Sound Length (R/W)
+    GB_IO_NR42       = 0x21, // Channel 4 Volume Envelope (R/W)
+    GB_IO_NR43       = 0x22, // Channel 4 Polynomial Counter (R/W)
+    GB_IO_NR44       = 0x23, // Channel 4 Counter/consecutive, Inital (R/W)
+    GB_IO_NR50       = 0x24, // Channel control / ON-OFF / Volume (R/W)
+    GB_IO_NR51       = 0x25, // Selection of Sound output terminal (R/W)
+    GB_IO_NR52       = 0x26, // Sound on/off
+
+    /* Missing */
+
+    GB_IO_WAV_START  = 0x30, // Wave pattern start
+    GB_IO_WAV_END    = 0x3f, // Wave pattern end
+
+    /* Graphics */
+    GB_IO_LCDC       = 0x40, // LCD Control (R/W)
+    GB_IO_STAT       = 0x41, // LCDC Status (R/W)
+    GB_IO_SCY        = 0x42, // Scroll Y (R/W)
+    GB_IO_SCX        = 0x43, // Scroll X (R/W)
+    GB_IO_LY         = 0x44, // LCDC Y-Coordinate (R)
+    GB_IO_LYC        = 0x45, // LY Compare (R/W)
+    GB_IO_DMA        = 0x46, // DMA Transfer and Start Address (W)
+    GB_IO_BGP        = 0x47, // BG Palette Data (R/W) - Non CGB Mode Only
+    GB_IO_OBP0       = 0x48, // Object Palette 0 Data (R/W) - Non CGB Mode Only
+    GB_IO_OBP1       = 0x49, // Object Palette 1 Data (R/W) - Non CGB Mode Only
+    GB_IO_WY         = 0x4a, // Window Y Position (R/W)
+    GB_IO_WX         = 0x4b, // Window X Position minus 7 (R/W)
+    // Has some undocumented compatibility flags written at boot.
+    // Unfortunately it is not readable or writable after boot has finished, so research of this
+    // register is quite limited. The value written to this register, however, can be controlled
+    // in some cases.
+    GB_IO_DMG_EMULATION = 0x4c,
+
+    /* General CGB features */
+    GB_IO_KEY1       = 0x4d, // CGB Mode Only - Prepare Speed Switch
+
+    /* Missing */
+
+    GB_IO_VBK        = 0x4f, // CGB Mode Only - VRAM Bank
+    GB_IO_BIOS       = 0x50, // Write to disable the BIOS mapping
+
+    /* CGB DMA */
+    GB_IO_HDMA1      = 0x51, // CGB Mode Only - New DMA Source, High
+    GB_IO_HDMA2      = 0x52, // CGB Mode Only - New DMA Source, Low
+    GB_IO_HDMA3      = 0x53, // CGB Mode Only - New DMA Destination, High
+    GB_IO_HDMA4      = 0x54, // CGB Mode Only - New DMA Destination, Low
+    GB_IO_HDMA5      = 0x55, // CGB Mode Only - New DMA Length/Mode/Start
+
+    /* IR */
+    GB_IO_RP         = 0x56, // CGB Mode Only - Infrared Communications Port
+
+    /* Missing */
+
+    /* CGB Paletts */
+    GB_IO_BGPI       = 0x68, // CGB Mode Only - Background Palette Index
+    GB_IO_BGPD       = 0x69, // CGB Mode Only - Background Palette Data
+    GB_IO_OBPI       = 0x6a, // CGB Mode Only - Sprite Palette Index
+    GB_IO_OBPD       = 0x6b, // CGB Mode Only - Sprite Palette Data
+
+    // 1 is written for DMG ROMs on a CGB. Does not appear to have an effect.
+    GB_IO_DMG_EMULATION_INDICATION   = 0x6c, // (FEh) Bit 0 (Read/Write)
+
+    /* Missing */
+
+    GB_IO_SVBK       = 0x70, // CGB Mode Only - WRAM Bank
+    GB_IO_UNKNOWN2   = 0x72, // (00h) - Bit 0-7 (Read/Write)
+    GB_IO_UNKNOWN3   = 0x73, // (00h) - Bit 0-7 (Read/Write)
+    GB_IO_UNKNOWN4   = 0x74, // (00h) - Bit 0-7 (Read/Write) - CGB Mode Only
+    GB_IO_UNKNOWN5   = 0x75, // (8Fh) - Bit 4-6 (Read/Write)
+    GB_IO_PCM_12     = 0x76, // Channels 1 and 2 amplitudes
+    GB_IO_PCM_34     = 0x77, // Channels 3 and 4 amplitudes
+    GB_IO_UNKNOWN8   = 0x7F, // Unknown, write only
+};
+
+typedef enum {
+    GB_LOG_BOLD = 1,
+    GB_LOG_DASHED_UNDERLINE = 2,
+    GB_LOG_UNDERLINE = 4,
+    GB_LOG_UNDERLINE_MASK =  GB_LOG_DASHED_UNDERLINE | GB_LOG_UNDERLINE
+} GB_log_attributes;
+
+#ifdef GB_INTERNAL
+#define LCDC_PERIOD 70224
+#define CPU_FREQUENCY 0x400000
+#define SGB_NTSC_FREQUENCY (21477272 / 5)
+#define SGB_PAL_FREQUENCY (21281370 / 5)
+#define DIV_CYCLES (0x100)
+#define INTERNAL_DIV_CYCLES (0x40000)
+
+#if !defined(MIN)
+#define MIN(A,B)    ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __a : __b; })
+#endif
+
+#if !defined(MAX)
+#define MAX(A,B)    ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; })
+#endif
+#endif
+
+typedef void (*GB_vblank_callback_t)(GB_gameboy_t *gb);
+typedef void (*GB_log_callback_t)(GB_gameboy_t *gb, const char *string, GB_log_attributes attributes);
+typedef char *(*GB_input_callback_t)(GB_gameboy_t *gb);
+typedef uint32_t (*GB_rgb_encode_callback_t)(GB_gameboy_t *gb, uint8_t r, uint8_t g, uint8_t b);
+typedef void (*GB_infrared_callback_t)(GB_gameboy_t *gb, bool on, long cycles_since_last_update);
+typedef void (*GB_rumble_callback_t)(GB_gameboy_t *gb, bool rumble_on);
+typedef void (*GB_serial_transfer_bit_start_callback_t)(GB_gameboy_t *gb, bool bit_to_send);
+typedef bool (*GB_serial_transfer_bit_end_callback_t)(GB_gameboy_t *gb);
+typedef void (*GB_update_input_hint_callback_t)(GB_gameboy_t *gb);
+typedef void (*GB_joyp_write_callback_t)(GB_gameboy_t *gb, uint8_t value);
+typedef void (*GB_icd_pixel_callback_t)(GB_gameboy_t *gb, uint8_t row);
+typedef void (*GB_icd_hreset_callback_t)(GB_gameboy_t *gb);
+typedef void (*GB_icd_vreset_callback_t)(GB_gameboy_t *gb);
+
+typedef struct {
+    bool state;
+    long delay;
+} GB_ir_queue_item_t;
+
+struct GB_breakpoint_s;
+struct GB_watchpoint_s;
+
+typedef struct {
+    uint8_t pixel; // Color, 0-3
+    uint8_t palette; // Palette, 0 - 7 (CGB); 0-1 in DMG (or just 0 for BG)
+    uint8_t priority; // Sprite priority – 0 in DMG, OAM index in CGB
+    bool bg_priority; // For sprite FIFO – the BG priority bit. For the BG FIFO – the CGB attributes priority bit
+} GB_fifo_item_t;
+
+#define GB_FIFO_LENGTH 16
+typedef struct {
+    GB_fifo_item_t fifo[GB_FIFO_LENGTH];
+    uint8_t read_end;
+    uint8_t write_end;
+} GB_fifo_t;
+
+/* When state saving, each section is dumped independently of other sections.
+   This allows adding data to the end of the section without worrying about future compatibility.
+   Some other changes might be "safe" as well.
+   This struct is not packed, but dumped sections exclusively use types that have the same alignment in both 32 and 64
+   bit platforms. */
+
+/* We make sure bool is 1 for cross-platform save state compatibility. */
+/* Todo: We might want to typedef our own bool if this prevents SameBoy from working on specific platforms. */
+//_Static_assert(sizeof(bool) == 1, "sizeof(bool) != 1");
+
+#ifdef GB_INTERNAL
+struct GB_gameboy_s {
+#else
+struct GB_gameboy_internal_s {
+#endif
+    GB_SECTION(header,
+        /* The magic makes sure a state file is:
+            - Indeed a SameBoy state file.
+            - Has the same endianess has the current platform. */
+        volatile uint32_t magic;
+        /* The version field makes sure we don't load save state files with a completely different structure.
+           This happens when struct fields are removed/resized in an backward incompatible manner. */
+        uint32_t version;
+    );
+
+    GB_SECTION(core_state,
+        /* Registers */
+        uint16_t pc;
+           union {
+               uint16_t registers[GB_REGISTERS_16_BIT];
+               struct {
+                   uint16_t af,
+                            bc,
+                            de,
+                            hl,
+                            sp;
+               };
+               struct {
+#ifdef GB_BIG_ENDIAN
+                   uint8_t a, f,
+                           b, c,
+                           d, e,
+                           h, l;
+#else
+                   uint8_t f, a,
+                           c, b,
+                           e, d,
+                           l, h;
+#endif
+               };
+               
+           };
+        uint8_t ime;
+        uint8_t interrupt_enable;
+        uint8_t cgb_ram_bank;
+
+        /* CPU and General Hardware Flags*/
+        GB_model_t model;
+        bool cgb_mode;
+        bool cgb_double_speed;
+        bool halted;
+        bool stopped;
+        bool boot_rom_finished;
+        bool ime_toggle; /* ei has delayed a effect.*/
+        bool halt_bug;
+        bool just_halted;
+
+        /* Misc state */
+        bool infrared_input;
+        GB_printer_t printer;
+        uint8_t extra_oam[0xff00 - 0xfea0];
+        uint32_t ram_size; // Different between CGB and DMG
+    );
+
+    /* DMA and HDMA */
+    GB_SECTION(dma,
+        bool hdma_on;
+        bool hdma_on_hblank;
+        uint8_t hdma_steps_left;
+        int16_t hdma_cycles; // in 8MHz units
+        uint16_t hdma_current_src, hdma_current_dest;
+
+        uint8_t dma_steps_left;
+        uint8_t dma_current_dest;
+        uint16_t dma_current_src;
+        int16_t dma_cycles;
+        bool is_dma_restarting;
+        uint8_t last_opcode_read; /* Required to emulte HDMA reads from Exxx */
+        bool hdma_starting;
+    );
+    
+    /* MBC */
+    GB_SECTION(mbc,
+        uint16_t mbc_rom_bank;
+        uint8_t mbc_ram_bank;
+        uint32_t mbc_ram_size;
+        bool mbc_ram_enable;
+        union {
+            struct {
+                uint8_t bank_low:5;
+                uint8_t bank_high:2;
+                uint8_t mode:1;
+            } mbc1;
+
+            struct {
+                uint8_t rom_bank:4;
+            } mbc2;
+
+            struct {
+                uint8_t rom_bank:7;
+                uint8_t padding:1;
+                uint8_t ram_bank:4;
+            } mbc3;
+
+            struct {
+                uint8_t rom_bank_low;
+                uint8_t rom_bank_high:1;
+                uint8_t ram_bank:4;
+            } mbc5;
+            
+            struct {
+                uint8_t bank_low:6;
+                uint8_t bank_high:3;
+                uint8_t mode:1;
+            } huc1;
+
+            struct {
+                uint8_t rom_bank;
+                uint8_t ram_bank;
+            } huc3;
+        };
+        uint16_t mbc_rom0_bank; /* For some MBC1 wirings. */
+        bool camera_registers_mapped;
+        uint8_t camera_registers[0x36];
+        bool rumble_state;
+    );
+
+
+    /* HRAM and HW Registers */
+    GB_SECTION(hram,
+        uint8_t hram[0xFFFF - 0xFF80];
+        uint8_t io_registers[0x80];
+    );
+
+    /* Timing */
+    GB_SECTION(timing,
+        GB_UNIT(display);
+        GB_UNIT(div);
+        uint16_t div_counter;
+        uint8_t tima_reload_state; /* After TIMA overflows, it becomes 0 for 4 cycles before actually reloading. */
+        uint16_t serial_cycles;
+        uint16_t serial_length;
+        uint8_t double_speed_alignment;
+        uint8_t serial_count;
+    );
+
+    /* APU */
+    GB_SECTION(apu,
+        GB_apu_t apu;
+    );
+
+    /* RTC */
+    GB_SECTION(rtc,
+        GB_rtc_time_t rtc_real, rtc_latched;
+        uint64_t last_rtc_second;
+        bool rtc_latch;
+    );
+
+    /* Video Display */
+    GB_SECTION(video,
+        uint32_t vram_size; // Different between CGB and DMG
+        uint8_t cgb_vram_bank;
+        uint8_t oam[0xA0];
+        uint8_t background_palettes_data[0x40];
+        uint8_t sprite_palettes_data[0x40];
+        uint8_t position_in_line;
+        bool stat_interrupt_line;
+        uint8_t effective_scx;
+        uint8_t wy_diff;
+        /* The LCDC will skip the first frame it renders after turning it on.
+           On the CGB, a frame is not skipped if the previous frame was skipped as well.
+           See https://www.reddit.com/r/EmuDev/comments/6exyxu/ */
+               
+        /* TODO: Drop this and properly emulate the dropped vreset signal*/
+        enum {
+            GB_FRAMESKIP_LCD_TURNED_ON, // On a DMG, the LCD renders a blank screen during this state,
+                                        // on a CGB, the previous frame is repeated (which might be
+                                        // blank if the LCD was off for more than a few cycles)
+            GB_FRAMESKIP_FIRST_FRAME_SKIPPED, // This state is 'skipped' when emulating a DMG
+            GB_FRAMESKIP_SECOND_FRAME_RENDERED,
+        } frame_skip_state;
+        bool oam_read_blocked;
+        bool vram_read_blocked;
+        bool oam_write_blocked;
+        bool vram_write_blocked;
+        bool window_disabled_while_active;
+        uint8_t current_line;
+        uint16_t ly_for_comparison;
+        GB_fifo_t bg_fifo, oam_fifo;
+        uint8_t fetcher_x;
+        uint8_t fetcher_y;
+        uint16_t cycles_for_line;
+        uint8_t current_tile;
+        uint8_t current_tile_attributes;
+        uint8_t current_tile_data[2];
+        uint8_t fetcher_state;
+        bool bg_fifo_paused;
+        bool oam_fifo_paused;
+        bool in_window;
+        uint8_t visible_objs[10];
+        uint8_t obj_comparators[10];
+        uint8_t n_visible_objs;
+        uint8_t oam_search_index;
+        uint8_t accessed_oam_row;
+        uint8_t extra_penalty_for_sprite_at_0;
+        uint8_t mode_for_interrupt;
+        bool lyc_interrupt_line;
+        bool cgb_palettes_blocked;
+        uint8_t current_lcd_line; // The LCD can go out of sync since the vsync signal is skipped in some cases.
+        uint32_t cycles_in_stop_mode;
+    );
+
+    /* Unsaved data. This includes all pointers, as well as everything that shouldn't be on a save state */
+    /* This data is reserved on reset and must come last in the struct */
+    GB_SECTION(unsaved,
+        /* ROM */
+        uint8_t *rom;
+        uint32_t rom_size;
+        const GB_cartridge_t *cartridge_type;
+        enum {
+            GB_STANDARD_MBC1_WIRING,
+            GB_MBC1M_WIRING,
+        } mbc1_wiring;
+
+        unsigned pending_cycles;
+               
+        /* Various RAMs */
+        uint8_t *ram;
+        uint8_t *vram;
+        uint8_t *mbc_ram;
+
+        /* I/O */
+        uint32_t *screen;
+        uint32_t background_palettes_rgb[0x20];
+        uint32_t sprite_palettes_rgb[0x20];
+        GB_color_correction_mode_t color_correction_mode;
+        bool keys[4][GB_KEY_MAX];
+               
+        /* Timing */
+        uint64_t last_sync;
+        uint64_t cycles_since_last_sync; // In 8MHz units
+
+        /* Audio */
+        GB_apu_output_t apu_output;
+
+        /* Callbacks */
+        void *user_data;
+        GB_log_callback_t log_callback;
+        GB_input_callback_t input_callback;
+        GB_input_callback_t async_input_callback;
+        GB_rgb_encode_callback_t rgb_encode_callback;
+        GB_vblank_callback_t vblank_callback;
+        GB_infrared_callback_t infrared_callback;
+        GB_camera_get_pixel_callback_t camera_get_pixel_callback;
+        GB_camera_update_request_callback_t camera_update_request_callback;
+        GB_rumble_callback_t rumble_callback;
+        GB_serial_transfer_bit_start_callback_t serial_transfer_bit_start_callback;
+        GB_serial_transfer_bit_end_callback_t serial_transfer_bit_end_callback;
+        GB_update_input_hint_callback_t update_input_hint_callback;
+        GB_joyp_write_callback_t joyp_write_callback;
+        GB_icd_pixel_callback_t icd_pixel_callback;
+        GB_icd_vreset_callback_t icd_hreset_callback;
+        GB_icd_vreset_callback_t icd_vreset_callback;
+               
+        /* IR */
+        long cycles_since_ir_change; // In 8MHz units
+        long cycles_since_input_ir_change; // In 8MHz units
+        GB_ir_queue_item_t ir_queue[GB_MAX_IR_QUEUE];
+        size_t ir_queue_length;
+
+        /*** Debugger ***/
+        volatile bool debug_stopped, debug_disable;
+        bool debug_fin_command, debug_next_command;
+
+        /* Breakpoints */
+        uint16_t n_breakpoints;
+        struct GB_breakpoint_s *breakpoints;
+        bool has_jump_to_breakpoints;
+        void *nontrivial_jump_state;
+        bool non_trivial_jump_breakpoint_occured;
+
+        /* SLD (Todo: merge with backtrace) */
+        bool stack_leak_detection;
+        int debug_call_depth;
+        uint16_t sp_for_call_depth[0x200]; /* Should be much more than enough */
+        uint16_t addr_for_call_depth[0x200];
+
+        /* Backtrace */
+        unsigned backtrace_size;
+        uint16_t backtrace_sps[0x200];
+        struct {
+            uint16_t bank;
+            uint16_t addr;
+        } backtrace_returns[0x200];
+
+        /* Watchpoints */
+        uint16_t n_watchpoints;
+        struct GB_watchpoint_s *watchpoints;
+
+        /* Symbol tables */
+        GB_symbol_map_t *bank_symbols[0x200];
+        GB_reversed_symbol_map_t reversed_symbol_map;
+
+        /* Ticks command */
+        unsigned long debugger_ticks;
+               
+        /* Rewind */
+#define GB_REWIND_FRAMES_PER_KEY 255
+        size_t rewind_buffer_length;
+        struct {
+            uint8_t *key_state;
+            uint8_t *compressed_states[GB_REWIND_FRAMES_PER_KEY];
+            unsigned pos;
+        } *rewind_sequences; // lasts about 4 seconds
+        size_t rewind_pos;
+               
+        /* SGB - saved and allocated optionally */
+        GB_sgb_t *sgb;
+        
+        double sgb_intro_jingle_phases[7];
+        double sgb_intro_sweep_phase;
+        double sgb_intro_sweep_previous_sample;
+
+        /* Misc */
+        bool turbo;
+        bool turbo_dont_skip;
+        bool disable_rendering;
+        uint8_t boot_rom[0x900];
+        bool vblank_just_occured; // For slow operations involving syscalls; these should only run once per vblank
+        uint8_t cycles_since_run; // How many cycles have passed since the last call to GB_run(), in 8MHz units
+        double clock_multiplier;
+   );
+};
+    
+#ifndef GB_INTERNAL
+struct GB_gameboy_s {
+    char __internal[sizeof(struct GB_gameboy_internal_s)];
+};
+#endif
+
+
+#ifndef __printflike
+/* Missing from Linux headers. */
+#define __printflike(fmtarg, firstvararg) \
+__attribute__((__format__ (__printf__, fmtarg, firstvararg)))
+#endif
+
+void GB_init(GB_gameboy_t *gb, GB_model_t model);
+bool GB_is_inited(GB_gameboy_t *gb);
+bool GB_is_cgb(GB_gameboy_t *gb);
+bool GB_is_sgb(GB_gameboy_t *gb); // Returns true if the model is SGB or SGB2
+bool GB_is_hle_sgb(GB_gameboy_t *gb); // Returns true if the model is SGB or SGB2 and the SFC/SNES side is HLE'd
+GB_model_t GB_get_model(GB_gameboy_t *gb);
+void GB_free(GB_gameboy_t *gb);
+void GB_reset(GB_gameboy_t *gb);
+void GB_switch_model_and_reset(GB_gameboy_t *gb, GB_model_t model);
+
+/* Returns the time passed, in 8MHz ticks. */
+uint8_t GB_run(GB_gameboy_t *gb);
+/* Returns the time passed since the last frame, in nanoseconds */
+uint64_t GB_run_frame(GB_gameboy_t *gb);
+
+typedef enum {
+    GB_DIRECT_ACCESS_ROM,
+    GB_DIRECT_ACCESS_RAM,
+    GB_DIRECT_ACCESS_CART_RAM,
+    GB_DIRECT_ACCESS_VRAM,
+    GB_DIRECT_ACCESS_HRAM,
+    GB_DIRECT_ACCESS_IO, /* Warning: Some registers can only be read/written correctly via GB_memory_read/write. */
+    GB_DIRECT_ACCESS_BOOTROM,
+    GB_DIRECT_ACCESS_OAM,
+    GB_DIRECT_ACCESS_BGP,
+    GB_DIRECT_ACCESS_OBP,
+    GB_DIRECT_ACCESS_IE,
+} GB_direct_access_t;
+
+/* Returns a mutable pointer to various hardware memories. If that memory is banked, the current bank
+   is returned at *bank, even if only a portion of the memory is banked. */
+void *GB_get_direct_access(GB_gameboy_t *gb, GB_direct_access_t access, size_t *size, uint16_t *bank);
+
+void *GB_get_user_data(GB_gameboy_t *gb);
+void GB_set_user_data(GB_gameboy_t *gb, void *data);
+
+
+
+int GB_load_boot_rom(GB_gameboy_t *gb, const char *path);
+void GB_load_boot_rom_from_buffer(GB_gameboy_t *gb, const unsigned char *buffer, size_t size);
+int GB_load_rom(GB_gameboy_t *gb, const char *path);
+void GB_load_rom_from_buffer(GB_gameboy_t *gb, const uint8_t *buffer, size_t size);
+
+int GB_save_battery_size(GB_gameboy_t *gb);
+int GB_save_battery_to_buffer(GB_gameboy_t *gb, uint8_t *buffer, size_t size);
+int GB_save_battery(GB_gameboy_t *gb, const char *path);
+
+void GB_load_battery_from_buffer(GB_gameboy_t *gb, const uint8_t *buffer, size_t size);
+void GB_load_battery(GB_gameboy_t *gb, const char *path);
+
+void GB_set_turbo_mode(GB_gameboy_t *gb, bool on, bool no_frame_skip);
+void GB_set_rendering_disabled(GB_gameboy_t *gb, bool disabled);
+    
+void GB_log(GB_gameboy_t *gb, const char *fmt, ...) __printflike(2, 3);
+void GB_attributed_log(GB_gameboy_t *gb, GB_log_attributes attributes, const char *fmt, ...) __printflike(3, 4);
+
+void GB_set_pixels_output(GB_gameboy_t *gb, uint32_t *output);
+
+void GB_set_infrared_input(GB_gameboy_t *gb, bool state);
+void GB_queue_infrared_input(GB_gameboy_t *gb, bool state, long cycles_after_previous_change); /* In 8MHz units*/
+    
+void GB_set_vblank_callback(GB_gameboy_t *gb, GB_vblank_callback_t callback);
+void GB_set_log_callback(GB_gameboy_t *gb, GB_log_callback_t callback);
+void GB_set_input_callback(GB_gameboy_t *gb, GB_input_callback_t callback);
+void GB_set_async_input_callback(GB_gameboy_t *gb, GB_input_callback_t callback);
+void GB_set_rgb_encode_callback(GB_gameboy_t *gb, GB_rgb_encode_callback_t callback);
+void GB_set_infrared_callback(GB_gameboy_t *gb, GB_infrared_callback_t callback);
+void GB_set_rumble_callback(GB_gameboy_t *gb, GB_rumble_callback_t callback);
+void GB_set_update_input_hint_callback(GB_gameboy_t *gb, GB_update_input_hint_callback_t callback);
+
+/* These APIs are used when using internal clock */
+void GB_set_serial_transfer_bit_start_callback(GB_gameboy_t *gb, GB_serial_transfer_bit_start_callback_t callback);
+void GB_set_serial_transfer_bit_end_callback(GB_gameboy_t *gb, GB_serial_transfer_bit_end_callback_t callback);
+
+/* These APIs are used when using external clock */
+bool GB_serial_get_data_bit(GB_gameboy_t *gb);
+void GB_serial_set_data_bit(GB_gameboy_t *gb, bool data);
+    
+void GB_disconnect_serial(GB_gameboy_t *gb);
+    
+/* For integration with SFC/SNES emulators */
+void GB_set_joyp_write_callback(GB_gameboy_t *gb, GB_joyp_write_callback_t callback);
+void GB_set_icd_pixel_callback(GB_gameboy_t *gb, GB_icd_pixel_callback_t callback);
+void GB_set_icd_hreset_callback(GB_gameboy_t *gb, GB_icd_hreset_callback_t callback);
+void GB_set_icd_vreset_callback(GB_gameboy_t *gb, GB_icd_vreset_callback_t callback);
+    
+#ifdef GB_INTERNAL
+uint32_t GB_get_clock_rate(GB_gameboy_t *gb);
+#endif
+void GB_set_clock_multiplier(GB_gameboy_t *gb, double multiplier);
+
+unsigned GB_get_screen_width(GB_gameboy_t *gb);
+unsigned GB_get_screen_height(GB_gameboy_t *gb);
+double GB_get_usual_frame_rate(GB_gameboy_t *gb);
+unsigned GB_get_player_count(GB_gameboy_t *gb);
+
+#endif /* GB_h */

bsnes/gb/Core/gb_struct_def.h

@@ -0,0 +1,5 @@
+#ifndef gb_struct_def_h
+#define gb_struct_def_h
+struct GB_gameboy_s;
+typedef struct GB_gameboy_s GB_gameboy_t;
+#endif 

bsnes/gb/Core/joypad.c

@@ -0,0 +1,92 @@
+#include "gb.h"
+#include <assert.h>
+
+void GB_update_joyp(GB_gameboy_t *gb)
+{
+    if (gb->model & GB_MODEL_SGB_NO_SFC) return;
+    
+    uint8_t key_selection = 0;
+    uint8_t previous_state = 0;
+
+    /* Todo: add delay to key selection */
+    previous_state = gb->io_registers[GB_IO_JOYP] & 0xF;
+    key_selection = (gb->io_registers[GB_IO_JOYP] >> 4) & 3;
+    gb->io_registers[GB_IO_JOYP] &= 0xF0;
+    uint8_t current_player = gb->sgb? gb->sgb->current_player : 0;
+    switch (key_selection) {
+        case 3:
+            if (gb->sgb && gb->sgb->player_count > 1) {
+                gb->io_registers[GB_IO_JOYP] |= 0xF - current_player;
+            }
+            else {
+                /* Nothing is wired, all up */
+                gb->io_registers[GB_IO_JOYP] |= 0x0F;
+            }
+            break;
+
+        case 2:
+            /* Direction keys */
+            for (uint8_t i = 0; i < 4; i++) {
+                gb->io_registers[GB_IO_JOYP] |= (!gb->keys[current_player][i]) << i;
+            }
+            /* Forbid pressing two opposing keys, this breaks a lot of games; even if it's somewhat possible. */
+            if (!(gb->io_registers[GB_IO_JOYP] & 1)) {
+                gb->io_registers[GB_IO_JOYP] |= 2;
+            }
+            if (!(gb->io_registers[GB_IO_JOYP] & 4)) {
+                gb->io_registers[GB_IO_JOYP] |= 8;
+            }
+            break;
+
+        case 1:
+            /* Other keys */
+            for (uint8_t i = 0; i < 4; i++) {
+                gb->io_registers[GB_IO_JOYP] |= (!gb->keys[current_player][i + 4]) << i;
+            }
+            break;
+
+        case 0:
+            for (uint8_t i = 0; i < 4; i++) {
+                gb->io_registers[GB_IO_JOYP] |= (!(gb->keys[current_player][i] || gb->keys[current_player][i + 4])) << i;
+            }
+            break;
+
+        default:
+            break;
+    }
+    
+    /* Todo: This assumes the keys *always* bounce, which is incorrect when emulating an SGB */
+    if (previous_state != (gb->io_registers[GB_IO_JOYP] & 0xF)) {
+        /* The joypad interrupt DOES occur on CGB (Tested on CGB-E), unlike what some documents say. */
+        gb->io_registers[GB_IO_IF] |= 0x10;
+    }
+    
+    gb->io_registers[GB_IO_JOYP] |= 0xC0;
+}
+
+void GB_icd_set_joyp(GB_gameboy_t *gb, uint8_t value)
+{
+    uint8_t previous_state = gb->io_registers[GB_IO_JOYP] & 0xF;
+    gb->io_registers[GB_IO_JOYP] &= 0xF0;
+    gb->io_registers[GB_IO_JOYP] |= value & 0xF;
+    
+    if (previous_state & ~(gb->io_registers[GB_IO_JOYP] & 0xF)) {
+        gb->io_registers[GB_IO_IF] |= 0x10;
+    }
+
+}
+
+void GB_set_key_state(GB_gameboy_t *gb, GB_key_t index, bool pressed)
+{
+    assert(index >= 0 && index < GB_KEY_MAX);
+    gb->keys[0][index] = pressed;
+    GB_update_joyp(gb);
+}
+
+void GB_set_key_state_for_player(GB_gameboy_t *gb, GB_key_t index, unsigned player, bool pressed)
+{
+    assert(index >= 0 && index < GB_KEY_MAX);
+    assert(player < 4);
+    gb->keys[player][index] = pressed;
+    GB_update_joyp(gb);
+}

bsnes/gb/Core/joypad.h

@@ -0,0 +1,25 @@
+#ifndef joypad_h
+#define joypad_h
+#include "gb_struct_def.h"
+#include <stdbool.h>
+
+typedef enum {
+    GB_KEY_RIGHT,
+    GB_KEY_LEFT,
+    GB_KEY_UP,
+    GB_KEY_DOWN,
+    GB_KEY_A,
+    GB_KEY_B,
+    GB_KEY_SELECT,
+    GB_KEY_START,
+    GB_KEY_MAX
+} GB_key_t;
+
+void GB_set_key_state(GB_gameboy_t *gb, GB_key_t index, bool pressed);
+void GB_set_key_state_for_player(GB_gameboy_t *gb, GB_key_t index, unsigned player, bool pressed);
+void GB_icd_set_joyp(GB_gameboy_t *gb, uint8_t value);
+
+#ifdef GB_INTERNAL
+void GB_update_joyp(GB_gameboy_t *gb);
+#endif
+#endif /* joypad_h */

bsnes/gb/Core/mbc.c

@@ -0,0 +1,154 @@
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include "gb.h"
+
+const GB_cartridge_t GB_cart_defs[256] = {
+    // From http://gbdev.gg8.se/wiki/articles/The_Cartridge_Header#0147_-_Cartridge_Type
+    /* MBC        SUBTYPE          RAM    BAT.   RTC    RUMB.   */
+    {  GB_NO_MBC, GB_STANDARD_MBC, false, false, false, false}, // 00h  ROM ONLY
+    {  GB_MBC1  , GB_STANDARD_MBC, false, false, false, false}, // 01h  MBC1
+    {  GB_MBC1  , GB_STANDARD_MBC, true , false, false, false}, // 02h  MBC1+RAM
+    {  GB_MBC1  , GB_STANDARD_MBC, true , true , false, false}, // 03h  MBC1+RAM+BATTERY
+    [5] =
+    {  GB_MBC2  , GB_STANDARD_MBC, true , false, false, false}, // 05h  MBC2
+    {  GB_MBC2  , GB_STANDARD_MBC, true , true , false, false}, // 06h  MBC2+BATTERY
+    [8] =
+    {  GB_NO_MBC, GB_STANDARD_MBC, true , false, false, false}, // 08h  ROM+RAM
+    {  GB_NO_MBC, GB_STANDARD_MBC, true , true , false, false}, // 09h  ROM+RAM+BATTERY
+    [0xB] =
+    /* Todo: Not supported yet */
+    {  GB_NO_MBC, GB_STANDARD_MBC, false, false, false, false}, // 0Bh  MMM01
+    {  GB_NO_MBC, GB_STANDARD_MBC, false, false, false, false}, // 0Ch  MMM01+RAM
+    {  GB_NO_MBC, GB_STANDARD_MBC, false, false, false, false}, // 0Dh  MMM01+RAM+BATTERY
+    [0xF] =
+    {  GB_MBC3  , GB_STANDARD_MBC, false, true,  true , false}, // 0Fh  MBC3+TIMER+BATTERY
+    {  GB_MBC3  , GB_STANDARD_MBC, true , true,  true , false}, // 10h  MBC3+TIMER+RAM+BATTERY
+    {  GB_MBC3  , GB_STANDARD_MBC, false, false, false, false}, // 11h  MBC3
+    {  GB_MBC3  , GB_STANDARD_MBC, true , false, false, false}, // 12h  MBC3+RAM
+    {  GB_MBC3  , GB_STANDARD_MBC, true , true , false, false}, // 13h  MBC3+RAM+BATTERY
+    [0x19] =
+    {  GB_MBC5  , GB_STANDARD_MBC, false, false, false, false}, // 19h  MBC5
+    {  GB_MBC5  , GB_STANDARD_MBC, true , false, false, false}, // 1Ah  MBC5+RAM
+    {  GB_MBC5  , GB_STANDARD_MBC, true , true , false, false}, // 1Bh  MBC5+RAM+BATTERY
+    {  GB_MBC5  , GB_STANDARD_MBC, false, false, false, true }, // 1Ch  MBC5+RUMBLE
+    {  GB_MBC5  , GB_STANDARD_MBC, true , false, false, true }, // 1Dh  MBC5+RUMBLE+RAM
+    {  GB_MBC5  , GB_STANDARD_MBC, true , true , false, true }, // 1Eh  MBC5+RUMBLE+RAM+BATTERY
+    [0xFC] =
+    {  GB_MBC5  , GB_CAMERA      , true , true , false, false}, // FCh  POCKET CAMERA
+    {  GB_NO_MBC, GB_STANDARD_MBC, false, false, false, false}, // FDh  BANDAI TAMA5 (Todo: Not supported)
+    {  GB_HUC3  , GB_STANDARD_MBC, true , true , false, false}, // FEh  HuC3 (Todo: Mapper support only)
+    {  GB_HUC1  , GB_STANDARD_MBC, true , true , false, false}, // FFh  HuC1+RAM+BATTERY (Todo: No IR bindings)
+};
+
+void GB_update_mbc_mappings(GB_gameboy_t *gb)
+{
+    switch (gb->cartridge_type->mbc_type) {
+        case GB_NO_MBC: return;
+        case GB_MBC1:
+            switch (gb->mbc1_wiring) {
+                case GB_STANDARD_MBC1_WIRING:
+                    gb->mbc_rom_bank = gb->mbc1.bank_low | (gb->mbc1.bank_high << 5);
+                    if (gb->mbc1.mode == 0) {
+                        gb->mbc_ram_bank = 0;
+                        gb->mbc_rom0_bank = 0;
+                    }
+                    else {
+                        gb->mbc_ram_bank = gb->mbc1.bank_high;
+                        gb->mbc_rom0_bank = gb->mbc1.bank_high << 5;
+                    }
+                    if ((gb->mbc_rom_bank & 0x1F) == 0) {
+                        gb->mbc_rom_bank++;
+                    }
+                    break;
+                case GB_MBC1M_WIRING:
+                    gb->mbc_rom_bank = (gb->mbc1.bank_low & 0xF) | (gb->mbc1.bank_high << 4);
+                    if (gb->mbc1.mode == 0) {
+                        gb->mbc_ram_bank = 0;
+                        gb->mbc_rom0_bank = 0;
+                    }
+                    else {
+                        gb->mbc_rom0_bank = gb->mbc1.bank_high << 4;
+                        gb->mbc_ram_bank = 0;
+                    }
+                    if ((gb->mbc1.bank_low & 0x1F) == 0) {
+                        gb->mbc_rom_bank++;
+                    }
+                    break;
+            }
+            break;
+        case GB_MBC2:
+            gb->mbc_rom_bank = gb->mbc2.rom_bank;
+            if ((gb->mbc_rom_bank & 0xF) == 0) {
+                gb->mbc_rom_bank = 1;
+            }
+            break;
+        case GB_MBC3:
+            gb->mbc_rom_bank = gb->mbc3.rom_bank;
+            gb->mbc_ram_bank = gb->mbc3.ram_bank;
+            if (gb->mbc_rom_bank == 0) {
+                gb->mbc_rom_bank = 1;
+            }
+            break;
+        case GB_MBC5:
+            gb->mbc_rom_bank = gb->mbc5.rom_bank_low | (gb->mbc5.rom_bank_high << 8);
+            gb->mbc_ram_bank = gb->mbc5.ram_bank;
+            break;
+        case GB_HUC1:
+            if (gb->huc1.mode == 0) {
+                gb->mbc_rom_bank = gb->huc1.bank_low | (gb->mbc1.bank_high << 6);
+                gb->mbc_ram_bank = 0;
+            }
+            else {
+                gb->mbc_rom_bank = gb->huc1.bank_low;
+                gb->mbc_ram_bank = gb->huc1.bank_high;
+            }
+            break;
+        case GB_HUC3:
+            gb->mbc_rom_bank = gb->huc3.rom_bank;
+            gb->mbc_ram_bank = gb->huc3.ram_bank;
+            break;
+    }
+}
+
+void GB_configure_cart(GB_gameboy_t *gb)
+{
+    gb->cartridge_type = &GB_cart_defs[gb->rom[0x147]];
+    
+    if (gb->rom[0x147] == 0 && gb->rom_size > 0x8000) {
+        GB_log(gb, "ROM header reports no MBC, but file size is over 32Kb. Assuming cartridge uses MBC3.\n");
+        gb->cartridge_type = &GB_cart_defs[0x11];
+    }
+    else if (gb->rom[0x147] != 0 && memcmp(gb->cartridge_type, &GB_cart_defs[0], sizeof(GB_cart_defs[0])) == 0) {
+        GB_log(gb, "Cartridge type %02x is not yet supported.\n", gb->rom[0x147]);
+    }
+
+    if (gb->cartridge_type->has_ram) {
+        if (gb->cartridge_type->mbc_type == GB_MBC2) {
+            gb->mbc_ram_size = 0x200;
+        }
+        else {
+            static const int ram_sizes[256] = {0, 0x800, 0x2000, 0x8000, 0x20000, 0x10000};
+            gb->mbc_ram_size = ram_sizes[gb->rom[0x149]];
+        }
+        gb->mbc_ram = malloc(gb->mbc_ram_size);
+
+        /* Todo: Some games assume unintialized MBC RAM is 0xFF. It this true for all cartridges types? */
+        memset(gb->mbc_ram, 0xFF, gb->mbc_ram_size);
+    }
+
+    /* MBC1 has at least 3 types of wiring (We currently support two (Standard and 4bit-MBC1M) of these).
+       See http://forums.nesdev.com/viewtopic.php?f=20&t=14099 */
+
+    /* Attempt to "guess" wiring */
+    if (gb->cartridge_type->mbc_type == GB_MBC1) {
+        if (gb->rom_size >= 0x44000 && memcmp(gb->rom + 0x104, gb->rom + 0x40104, 0x30) == 0) {
+            gb->mbc1_wiring = GB_MBC1M_WIRING;
+        }
+    }
+    
+    /* Set MBC5's bank to 1 correctly */
+    if (gb->cartridge_type->mbc_type == GB_MBC5) {
+        gb->mbc5.rom_bank_low = 1;
+    }
+}

bsnes/gb/Core/mbc.h

@@ -0,0 +1,32 @@
+#ifndef MBC_h
+#define MBC_h
+#include "gb_struct_def.h"
+#include <stdbool.h>
+
+typedef struct {
+    enum {
+        GB_NO_MBC,
+        GB_MBC1,
+        GB_MBC2,
+        GB_MBC3,
+        GB_MBC5,
+        GB_HUC1, /* Todo: HUC1 features are not emulated. Should be unified with the CGB IR sensor API. */
+        GB_HUC3,
+    } mbc_type;
+    enum {
+        GB_STANDARD_MBC,
+        GB_CAMERA,
+    } mbc_subtype;
+    bool has_ram;
+    bool has_battery;
+    bool has_rtc;
+    bool has_rumble;
+} GB_cartridge_t;
+
+#ifdef GB_INTERNAL
+extern const GB_cartridge_t GB_cart_defs[256];
+void GB_update_mbc_mappings(GB_gameboy_t *gb);
+void GB_configure_cart(GB_gameboy_t *gb);
+#endif
+
+#endif /* MBC_h */

bsnes/gb/Core/memory.h

@@ -0,0 +1,18 @@
+#ifndef memory_h
+#define memory_h
+#include "gb_struct_def.h"
+#include <stdint.h>
+
+typedef uint8_t (*GB_read_memory_callback_t)(GB_gameboy_t *gb, uint16_t addr, uint8_t data);
+void GB_set_read_memory_callback(GB_gameboy_t *gb, GB_read_memory_callback_t callback);
+
+uint8_t GB_read_memory(GB_gameboy_t *gb, uint16_t addr);
+void GB_write_memory(GB_gameboy_t *gb, uint16_t addr, uint8_t value);
+#ifdef GB_INTERNAL
+void GB_dma_run(GB_gameboy_t *gb);
+void GB_hdma_run(GB_gameboy_t *gb);
+void GB_trigger_oam_bug(GB_gameboy_t *gb, uint16_t address);
+void GB_trigger_oam_bug_read_increase(GB_gameboy_t *gb, uint16_t address);
+#endif
+
+#endif /* memory_h */

bsnes/gb/Core/printer.c

@@ -0,0 +1,216 @@
+#include "gb.h"
+
+/* TODO: Emulation is VERY basic and assumes the ROM correctly uses the printer's interface.
+         Incorrect usage is not correctly emulated, as it's not well documented, nor do I
+         have my own GB Printer to figure it out myself.
+ 
+         It also does not currently emulate communication timeout, which means that a bug
+         might prevent the printer operation until the GameBoy is restarted.
+ 
+         Also, field mask values are assumed. */
+
+static void handle_command(GB_gameboy_t *gb)
+{
+    
+    switch (gb->printer.command_id) {
+        case GB_PRINTER_INIT_COMMAND:
+            gb->printer.status = 0;
+            gb->printer.image_offset = 0;
+            break;
+            
+        case GB_PRINTER_START_COMMAND:
+            if (gb->printer.command_length == 4) {
+                gb->printer.status = 6; /* Printing */
+                uint32_t image[gb->printer.image_offset];
+                uint8_t palette = gb->printer.command_data[2];
+                uint32_t colors[4] = {gb->rgb_encode_callback(gb, 0xff, 0xff, 0xff),
+                                      gb->rgb_encode_callback(gb, 0xaa, 0xaa, 0xaa),
+                                      gb->rgb_encode_callback(gb, 0x55, 0x55, 0x55),
+                                      gb->rgb_encode_callback(gb, 0x00, 0x00, 0x00)};
+                for (unsigned i = 0; i < gb->printer.image_offset; i++) {
+                    image[i] = colors[(palette >> (gb->printer.image[i] * 2)) & 3];
+                }
+                
+                if (gb->printer.callback) {
+                    gb->printer.callback(gb, image, gb->printer.image_offset / 160,
+                                         gb->printer.command_data[1] >> 4, gb->printer.command_data[1] & 7,
+                                         gb->printer.command_data[3] & 0x7F);
+                }
+                
+                gb->printer.image_offset = 0;
+            }
+            break;
+            
+        case GB_PRINTER_DATA_COMMAND:
+            if (gb->printer.command_length == GB_PRINTER_DATA_SIZE) {
+                gb->printer.image_offset %= sizeof(gb->printer.image);
+                gb->printer.status = 8; /* Received 0x280 bytes */
+                
+                uint8_t *byte = gb->printer.command_data;
+                
+                for (unsigned row = 2; row--; ) {
+                    for (unsigned tile_x = 0; tile_x < 160 / 8; tile_x++) {
+                        for (unsigned y = 0; y < 8; y++, byte += 2) {
+                            for (unsigned x_pixel = 0; x_pixel < 8; x_pixel++) {
+                                    gb->printer.image[gb->printer.image_offset + tile_x * 8 + x_pixel + y * 160] =
+                                        ((*byte) >> 7) | (((*(byte + 1)) >> 7) << 1);
+                                    (*byte) <<= 1;
+                                    (*(byte + 1)) <<= 1;
+                            }
+                        }
+                    }
+                    
+                    gb->printer.image_offset += 8 * 160;
+                }
+            }
+            
+        case GB_PRINTER_NOP_COMMAND:
+        default:
+            break;
+    }
+}
+
+
+static void byte_reieve_completed(GB_gameboy_t *gb, uint8_t byte_received)
+{
+    gb->printer.byte_to_send = 0;
+    switch (gb->printer.command_state) {
+        case GB_PRINTER_COMMAND_MAGIC1:
+            if (byte_received != 0x88) {
+                return;
+            }
+            gb->printer.status &= ~1;
+            gb->printer.command_length = 0;
+            gb->printer.checksum = 0;
+            break;
+            
+        case GB_PRINTER_COMMAND_MAGIC2:
+            if (byte_received != 0x33) {
+                if (byte_received != 0x88) {
+                    gb->printer.command_state = GB_PRINTER_COMMAND_MAGIC1;
+                }
+                return;
+            }
+            break;
+            
+        case GB_PRINTER_COMMAND_ID:
+            gb->printer.command_id = byte_received & 0xF;
+            break;
+            
+        case GB_PRINTER_COMMAND_COMPRESSION:
+            gb->printer.compression = byte_received & 1;
+            break;
+            
+        case GB_PRINTER_COMMAND_LENGTH_LOW:
+            gb->printer.length_left = byte_received;
+            break;
+            
+        case GB_PRINTER_COMMAND_LENGTH_HIGH:
+            gb->printer.length_left |= (byte_received & 3) << 8;
+            break;
+            
+        case GB_PRINTER_COMMAND_DATA:
+            if (gb->printer.command_length != GB_PRINTER_MAX_COMMAND_LENGTH) {
+                if (gb->printer.compression) {
+                    if (!gb->printer.compression_run_lenth) {
+                        gb->printer.compression_run_is_compressed = byte_received & 0x80;
+                        gb->printer.compression_run_lenth = (byte_received & 0x7F) + 1 + gb->printer.compression_run_is_compressed;
+                    }
+                    else if (gb->printer.compression_run_is_compressed) {
+                        while (gb->printer.compression_run_lenth) {
+                            gb->printer.command_data[gb->printer.command_length++] = byte_received;
+                            gb->printer.compression_run_lenth--;
+                            if (gb->printer.command_length == GB_PRINTER_MAX_COMMAND_LENGTH) {
+                                gb->printer.compression_run_lenth = 0;
+                            }
+                        }
+                    }
+                    else {
+                        gb->printer.command_data[gb->printer.command_length++] = byte_received;
+                        gb->printer.compression_run_lenth--;
+                    }
+                }
+                else {
+                    gb->printer.command_data[gb->printer.command_length++] = byte_received;
+                }
+            }
+            gb->printer.length_left--;
+            break;
+            
+        case GB_PRINTER_COMMAND_CHECKSUM_LOW:
+            gb->printer.checksum ^= byte_received;
+            break;
+            
+        case GB_PRINTER_COMMAND_CHECKSUM_HIGH:
+            gb->printer.checksum ^= byte_received << 8;
+            if (gb->printer.checksum) {
+                gb->printer.status |= 1; /* Checksum error*/
+                gb->printer.command_state = GB_PRINTER_COMMAND_MAGIC1;
+                return;
+            }
+            gb->printer.byte_to_send = 0x81;
+
+            break;
+        case GB_PRINTER_COMMAND_ACTIVE:
+            if ((gb->printer.command_id & 0xF) == GB_PRINTER_INIT_COMMAND) {
+                /* Games expect INIT commands to return 0? */
+                gb->printer.byte_to_send = 0;
+            }
+            else {
+                gb->printer.byte_to_send = gb->printer.status;
+            }
+            break;
+        case GB_PRINTER_COMMAND_STATUS:
+            
+            /* Printing is done instantly, but let the game recieve a 6 (Printing) status at least once, for compatibility */
+            if (gb->printer.status == 6) {
+               gb->printer.status = 4; /* Done */
+            }
+            
+            gb->printer.command_state = GB_PRINTER_COMMAND_MAGIC1;
+            handle_command(gb);
+            return;
+    }
+
+    if (gb->printer.command_state >= GB_PRINTER_COMMAND_ID && gb->printer.command_state < GB_PRINTER_COMMAND_CHECKSUM_LOW) {
+        gb->printer.checksum += byte_received;
+    }
+
+    if (gb->printer.command_state != GB_PRINTER_COMMAND_DATA) {
+        gb->printer.command_state++;
+    }
+
+    if (gb->printer.command_state == GB_PRINTER_COMMAND_DATA) {
+        if (gb->printer.length_left == 0) {
+            gb->printer.command_state++;
+        }
+    }
+}
+
+static void serial_start(GB_gameboy_t *gb, bool bit_received)
+{
+    gb->printer.byte_being_recieved <<= 1;
+    gb->printer.byte_being_recieved |= bit_received;
+    gb->printer.bits_recieved++;
+    if (gb->printer.bits_recieved == 8) {
+        byte_reieve_completed(gb, gb->printer.byte_being_recieved);
+        gb->printer.bits_recieved = 0;
+        gb->printer.byte_being_recieved = 0;
+    }
+}
+
+static bool serial_end(GB_gameboy_t *gb)
+{
+    bool ret = gb->printer.bit_to_send;
+    gb->printer.bit_to_send = gb->printer.byte_to_send & 0x80;
+    gb->printer.byte_to_send <<= 1;
+    return ret;
+}
+
+void GB_connect_printer(GB_gameboy_t *gb, GB_print_image_callback_t callback)
+{
+    memset(&gb->printer, 0, sizeof(gb->printer));
+    GB_set_serial_transfer_bit_start_callback(gb, serial_start);
+    GB_set_serial_transfer_bit_end_callback(gb, serial_end);
+    gb->printer.callback = callback;
+}

bsnes/gb/Core/printer.h

@@ -0,0 +1,63 @@
+#ifndef printer_h
+#define printer_h
+#include <stdint.h>
+#include <stdbool.h>
+#include "gb_struct_def.h"
+#define GB_PRINTER_MAX_COMMAND_LENGTH 0x280
+#define GB_PRINTER_DATA_SIZE 0x280
+
+typedef void (*GB_print_image_callback_t)(GB_gameboy_t *gb,
+                                          uint32_t *image,
+                                          uint8_t height,
+                                          uint8_t top_margin,
+                                          uint8_t bottom_margin,
+                                          uint8_t exposure);
+
+
+typedef struct
+{
+    /* Communication state machine */
+
+    enum {
+        GB_PRINTER_COMMAND_MAGIC1,
+        GB_PRINTER_COMMAND_MAGIC2,
+        GB_PRINTER_COMMAND_ID,
+        GB_PRINTER_COMMAND_COMPRESSION,
+        GB_PRINTER_COMMAND_LENGTH_LOW,
+        GB_PRINTER_COMMAND_LENGTH_HIGH,
+        GB_PRINTER_COMMAND_DATA,
+        GB_PRINTER_COMMAND_CHECKSUM_LOW,
+        GB_PRINTER_COMMAND_CHECKSUM_HIGH,
+        GB_PRINTER_COMMAND_ACTIVE,
+        GB_PRINTER_COMMAND_STATUS,
+    } command_state : 8;
+    enum {
+        GB_PRINTER_INIT_COMMAND = 1,
+        GB_PRINTER_START_COMMAND = 2,
+        GB_PRINTER_DATA_COMMAND = 4,
+        GB_PRINTER_NOP_COMMAND = 0xF,
+    } command_id : 8;
+    bool compression;
+    uint16_t length_left;
+    uint8_t command_data[GB_PRINTER_MAX_COMMAND_LENGTH];
+    uint16_t command_length;
+    uint16_t checksum;
+    uint8_t status;
+    uint8_t byte_to_send;
+    
+    uint8_t image[160 * 200];
+    uint16_t image_offset;
+    
+    GB_print_image_callback_t callback;
+    
+    uint8_t compression_run_lenth;
+    bool compression_run_is_compressed;
+    
+    uint8_t bits_recieved;
+    uint8_t byte_being_recieved;
+    bool bit_to_send;
+} GB_printer_t;
+
+
+void GB_connect_printer(GB_gameboy_t *gb, GB_print_image_callback_t callback);
+#endif

bsnes/gb/Core/random.c

@@ -0,0 +1,38 @@
+#include "random.h"
+#include <time.h>
+
+static uint64_t seed;
+static bool enabled = true;
+
+uint8_t GB_random(void)
+{
+    if (!enabled) return 0;
+    
+    seed *= 0x27BB2EE687B0B0FDL;
+    seed += 0xB504F32D;
+    return seed >> 56;
+}
+
+uint32_t GB_random32(void)
+{
+    GB_random();
+    return seed >> 32;
+}
+
+void GB_random_seed(uint64_t new_seed)
+{
+    seed = new_seed;
+}
+
+void GB_random_set_enabled(bool enable)
+{
+    enabled = enable;
+}
+
+static void __attribute__((constructor)) init_seed(void)
+{
+    seed = time(NULL);
+    for (unsigned i = 64; i--;) {
+        GB_random();
+    }
+}

bsnes/gb/Core/random.h

@@ -0,0 +1,12 @@
+#ifndef random_h
+#define random_h
+
+#include <stdint.h>
+#include <stdbool.h>
+
+uint8_t GB_random(void);
+uint32_t GB_random32(void);
+void GB_random_seed(uint64_t seed);
+void GB_random_set_enabled(bool enable);
+
+#endif /* random_h */

bsnes/gb/Core/rewind.c

@@ -0,0 +1,208 @@
+#include "gb.h"
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <math.h>
+
+static uint8_t *state_compress(const uint8_t *prev, const uint8_t *data, size_t uncompressed_size)
+{
+    size_t malloc_size = 0x1000;
+    uint8_t *compressed = malloc(malloc_size);
+    size_t counter_pos = 0;
+    size_t data_pos = sizeof(uint16_t);
+    bool prev_mode = true;
+    *(uint16_t *)compressed = 0;
+#define COUNTER (*(uint16_t *)&compressed[counter_pos])
+#define DATA (compressed[data_pos])
+    
+    while (uncompressed_size) {
+        if (prev_mode) {
+            if (*data == *prev && COUNTER != 0xffff) {
+                COUNTER++;
+                data++;
+                prev++;
+                uncompressed_size--;
+            }
+            else {
+                prev_mode = false;
+                counter_pos += sizeof(uint16_t);
+                data_pos = counter_pos + sizeof(uint16_t);
+                if (data_pos >= malloc_size) {
+                    malloc_size *= 2;
+                    compressed = realloc(compressed, malloc_size);
+                }
+                COUNTER = 0;
+            }
+        }
+        else {
+            if (*data != *prev && COUNTER != 0xffff) {
+                COUNTER++;
+                DATA = *data;
+                data_pos++;
+                data++;
+                prev++;
+                uncompressed_size--;
+                if (data_pos >= malloc_size) {
+                    malloc_size *= 2;
+                    compressed = realloc(compressed, malloc_size);
+                }
+            }
+            else {
+                prev_mode = true;
+                counter_pos = data_pos;
+                data_pos = counter_pos + sizeof(uint16_t);
+                if (counter_pos >= malloc_size - 1) {
+                    malloc_size *= 2;
+                    compressed = realloc(compressed, malloc_size);
+                }
+                COUNTER = 0;
+            }
+        }
+    }
+    
+    return  realloc(compressed, data_pos);
+#undef DATA
+#undef COUNTER
+}
+
+
+static void state_decompress(const uint8_t *prev, uint8_t *data, uint8_t *dest, size_t uncompressed_size)
+{
+    size_t counter_pos = 0;
+    size_t data_pos = sizeof(uint16_t);
+    bool prev_mode = true;
+#define COUNTER (*(uint16_t *)&data[counter_pos])
+#define DATA (data[data_pos])
+    
+    while (uncompressed_size) {
+        if (prev_mode) {
+            if (COUNTER) {
+                COUNTER--;
+                *(dest++) = *(prev++);
+                uncompressed_size--;
+            }
+            else {
+                prev_mode = false;
+                counter_pos += sizeof(uint16_t);
+                data_pos = counter_pos + sizeof(uint16_t);
+            }
+        }
+        else {
+            if (COUNTER) {
+                COUNTER--;
+                *(dest++) = DATA;
+                data_pos++;
+                prev++;
+                uncompressed_size--;
+            }
+            else {
+                prev_mode = true;
+                counter_pos = data_pos;
+                data_pos += sizeof(uint16_t);
+            }
+        }
+    }
+#undef DATA
+#undef COUNTER
+}
+
+void GB_rewind_push(GB_gameboy_t *gb)
+{
+    const size_t save_size = GB_get_save_state_size(gb);
+    if (!gb->rewind_sequences) {
+        if (gb->rewind_buffer_length) {
+            gb->rewind_sequences = malloc(sizeof(*gb->rewind_sequences) * gb->rewind_buffer_length);
+            memset(gb->rewind_sequences, 0, sizeof(*gb->rewind_sequences) * gb->rewind_buffer_length);
+            gb->rewind_pos = 0;
+        }
+        else {
+            return;
+        }
+    }
+    
+    if (gb->rewind_sequences[gb->rewind_pos].pos == GB_REWIND_FRAMES_PER_KEY) {
+        gb->rewind_pos++;
+        if (gb->rewind_pos == gb->rewind_buffer_length) {
+            gb->rewind_pos = 0;
+        }
+        if (gb->rewind_sequences[gb->rewind_pos].key_state) {
+            free(gb->rewind_sequences[gb->rewind_pos].key_state);
+            gb->rewind_sequences[gb->rewind_pos].key_state = NULL;
+        }
+        for (unsigned i = 0; i < GB_REWIND_FRAMES_PER_KEY; i++) {
+            if (gb->rewind_sequences[gb->rewind_pos].compressed_states[i]) {
+                free(gb->rewind_sequences[gb->rewind_pos].compressed_states[i]);
+                gb->rewind_sequences[gb->rewind_pos].compressed_states[i] = 0;
+            }
+        }
+        gb->rewind_sequences[gb->rewind_pos].pos = 0;
+    }
+    
+    if (!gb->rewind_sequences[gb->rewind_pos].key_state) {
+        gb->rewind_sequences[gb->rewind_pos].key_state = malloc(save_size);
+        GB_save_state_to_buffer(gb, gb->rewind_sequences[gb->rewind_pos].key_state);
+    }
+    else {
+        uint8_t *save_state = malloc(save_size);
+        GB_save_state_to_buffer(gb, save_state);
+        gb->rewind_sequences[gb->rewind_pos].compressed_states[gb->rewind_sequences[gb->rewind_pos].pos++] =
+            state_compress(gb->rewind_sequences[gb->rewind_pos].key_state, save_state, save_size);
+        free(save_state);
+    }
+    
+}
+
+bool GB_rewind_pop(GB_gameboy_t *gb)
+{
+    if (!gb->rewind_sequences || !gb->rewind_sequences[gb->rewind_pos].key_state) {
+        return false;
+    }
+    
+    const size_t save_size = GB_get_save_state_size(gb);
+    if (gb->rewind_sequences[gb->rewind_pos].pos == 0) {
+        GB_load_state_from_buffer(gb, gb->rewind_sequences[gb->rewind_pos].key_state, save_size);
+        free(gb->rewind_sequences[gb->rewind_pos].key_state);
+        gb->rewind_sequences[gb->rewind_pos].key_state = NULL;
+        gb->rewind_pos = gb->rewind_pos == 0? gb->rewind_buffer_length - 1 : gb->rewind_pos - 1;
+        return true;
+    }
+    
+    uint8_t *save_state = malloc(save_size);
+    state_decompress(gb->rewind_sequences[gb->rewind_pos].key_state,
+                     gb->rewind_sequences[gb->rewind_pos].compressed_states[--gb->rewind_sequences[gb->rewind_pos].pos],
+                     save_state,
+                     save_size);
+    free(gb->rewind_sequences[gb->rewind_pos].compressed_states[gb->rewind_sequences[gb->rewind_pos].pos]);
+    gb->rewind_sequences[gb->rewind_pos].compressed_states[gb->rewind_sequences[gb->rewind_pos].pos] = NULL;
+    GB_load_state_from_buffer(gb, save_state, save_size);
+    free(save_state);
+    return true;
+}
+
+void GB_rewind_free(GB_gameboy_t *gb)
+{
+    if (!gb->rewind_sequences) return;
+    for (unsigned i = 0; i < gb->rewind_buffer_length; i++) {
+        if (gb->rewind_sequences[i].key_state) {
+            free(gb->rewind_sequences[i].key_state);
+        }
+        for (unsigned j = 0; j < GB_REWIND_FRAMES_PER_KEY; j++) {
+            if (gb->rewind_sequences[i].compressed_states[j]) {
+                free(gb->rewind_sequences[i].compressed_states[j]);
+            }
+        }
+    }
+    free(gb->rewind_sequences);
+    gb->rewind_sequences = NULL;
+}
+
+void GB_set_rewind_length(GB_gameboy_t *gb, double seconds)
+{
+    GB_rewind_free(gb);
+    if (seconds == 0) {
+        gb->rewind_buffer_length = 0;
+    }
+    else {
+        gb->rewind_buffer_length = (size_t) ceil(seconds * CPU_FREQUENCY / LCDC_PERIOD / GB_REWIND_FRAMES_PER_KEY);
+    }
+}

bsnes/gb/Core/rewind.h

@@ -0,0 +1,14 @@
+#ifndef rewind_h
+#define rewind_h
+
+#include <stdbool.h>
+#include "gb_struct_def.h"
+
+#ifdef GB_INTERNAL
+void GB_rewind_push(GB_gameboy_t *gb);
+void GB_rewind_free(GB_gameboy_t *gb);
+#endif
+bool GB_rewind_pop(GB_gameboy_t *gb);
+void GB_set_rewind_length(GB_gameboy_t *gb, double seconds);
+
+#endif

bsnes/gb/Core/save_state.c

@@ -0,0 +1,377 @@
+#include "gb.h"
+#include <stdio.h>
+#include <errno.h>
+
+static bool dump_section(FILE *f, const void *src, uint32_t size)
+{
+    if (fwrite(&size, 1, sizeof(size), f) != sizeof(size)) {
+        return false;
+    }
+    
+    if (fwrite(src, 1, size, f) != size) {
+        return false;
+    }
+    
+    return true;
+}
+
+#define DUMP_SECTION(gb, f, section) dump_section(f, GB_GET_SECTION(gb, section), GB_SECTION_SIZE(section))
+
+/* Todo: we need a sane and protable save state format. */
+int GB_save_state(GB_gameboy_t *gb, const char *path)
+{
+    FILE *f = fopen(path, "wb");
+    if (!f) {
+        GB_log(gb, "Could not open save state: %s.\n", strerror(errno));
+        return errno;
+    }
+    
+    if (fwrite(GB_GET_SECTION(gb, header), 1, GB_SECTION_SIZE(header), f) != GB_SECTION_SIZE(header)) goto error;
+    if (!DUMP_SECTION(gb, f, core_state)) goto error;
+    if (!DUMP_SECTION(gb, f, dma       )) goto error;
+    if (!DUMP_SECTION(gb, f, mbc       )) goto error;
+    if (!DUMP_SECTION(gb, f, hram      )) goto error;
+    if (!DUMP_SECTION(gb, f, timing    )) goto error;
+    if (!DUMP_SECTION(gb, f, apu       )) goto error;
+    if (!DUMP_SECTION(gb, f, rtc       )) goto error;
+    if (!DUMP_SECTION(gb, f, video     )) goto error;
+    
+    if (GB_is_hle_sgb(gb)) {
+        if (!dump_section(f, gb->sgb, sizeof(*gb->sgb))) goto error;
+    }
+    
+    
+    if (fwrite(gb->mbc_ram, 1, gb->mbc_ram_size, f) != gb->mbc_ram_size) {
+        goto error;
+    }
+    
+    if (fwrite(gb->ram, 1, gb->ram_size, f) != gb->ram_size) {
+        goto error;
+    }
+    
+    if (fwrite(gb->vram, 1, gb->vram_size, f) != gb->vram_size) {
+        goto error;
+    }
+    
+    errno = 0;
+    
+error:
+    fclose(f);
+    return errno;
+}
+
+#undef DUMP_SECTION
+
+size_t GB_get_save_state_size(GB_gameboy_t *gb)
+{
+    return GB_SECTION_SIZE(header)
+    + GB_SECTION_SIZE(core_state) + sizeof(uint32_t)
+    + GB_SECTION_SIZE(dma       ) + sizeof(uint32_t)
+    + GB_SECTION_SIZE(mbc       ) + sizeof(uint32_t)
+    + GB_SECTION_SIZE(hram      ) + sizeof(uint32_t)
+    + GB_SECTION_SIZE(timing    ) + sizeof(uint32_t)
+    + GB_SECTION_SIZE(apu       ) + sizeof(uint32_t)
+    + GB_SECTION_SIZE(rtc       ) + sizeof(uint32_t)
+    + GB_SECTION_SIZE(video     ) + sizeof(uint32_t)
+    + (GB_is_hle_sgb(gb)? sizeof(*gb->sgb) + sizeof(uint32_t) : 0)
+    + gb->mbc_ram_size
+    + gb->ram_size
+    + gb->vram_size;
+}
+
+/* A write-line function for memory copying */
+static void buffer_write(const void *src, size_t size, uint8_t **dest)
+{
+    memcpy(*dest, src, size);
+    *dest += size;
+}
+
+static void buffer_dump_section(uint8_t **buffer, const void *src, uint32_t size)
+{
+    buffer_write(&size, sizeof(size), buffer);
+    buffer_write(src, size, buffer);
+}
+
+#define DUMP_SECTION(gb, buffer, section) buffer_dump_section(&buffer, GB_GET_SECTION(gb, section), GB_SECTION_SIZE(section))
+void GB_save_state_to_buffer(GB_gameboy_t *gb, uint8_t *buffer)
+{
+    buffer_write(GB_GET_SECTION(gb, header), GB_SECTION_SIZE(header), &buffer);
+    DUMP_SECTION(gb, buffer, core_state);
+    DUMP_SECTION(gb, buffer, dma       );
+    DUMP_SECTION(gb, buffer, mbc       );
+    DUMP_SECTION(gb, buffer, hram      );
+    DUMP_SECTION(gb, buffer, timing    );
+    DUMP_SECTION(gb, buffer, apu       );
+    DUMP_SECTION(gb, buffer, rtc       );
+    DUMP_SECTION(gb, buffer, video     );
+    
+    if (GB_is_hle_sgb(gb)) {
+        buffer_dump_section(&buffer, gb->sgb, sizeof(*gb->sgb));
+    }
+    
+    
+    buffer_write(gb->mbc_ram, gb->mbc_ram_size, &buffer);
+    buffer_write(gb->ram, gb->ram_size, &buffer);
+    buffer_write(gb->vram, gb->vram_size, &buffer);
+}
+
+/* Best-effort read function for maximum future compatibility. */
+static bool read_section(FILE *f, void *dest, uint32_t size)
+{
+    uint32_t saved_size = 0;
+    if (fread(&saved_size, 1, sizeof(size), f) != sizeof(size)) {
+        return false;
+    }
+    
+    if (saved_size <= size) {
+        if (fread(dest, 1, saved_size, f) != saved_size) {
+            return false;
+        }
+    }
+    else {
+        if (fread(dest, 1, size, f) != size) {
+            return false;
+        }
+        fseek(f, saved_size - size, SEEK_CUR);
+    }
+    
+    return true;
+}
+#undef DUMP_SECTION
+
+static bool verify_state_compatibility(GB_gameboy_t *gb, GB_gameboy_t *save)
+{
+    if (gb->magic != save->magic) {
+        GB_log(gb, "The file is not a save state, or is from an incompatible operating system.\n");
+        return false;
+    }
+    
+    if (gb->version != save->version) {
+        GB_log(gb, "The save state is for a different version of SameBoy.\n");
+        return false;
+    }
+    
+    if (gb->mbc_ram_size < save->mbc_ram_size) {
+        GB_log(gb, "The save state has non-matching MBC RAM size.\n");
+        return false;
+    }
+    
+    if (gb->vram_size != save->vram_size) {
+        GB_log(gb, "The save state has non-matching VRAM size. Try changing the emulated model.\n");
+        return false;
+    }
+    
+    if (GB_is_hle_sgb(gb) != GB_is_hle_sgb(save)) {
+        GB_log(gb, "The save state is %sfor a Super Game Boy. Try changing the emulated model.\n", GB_is_hle_sgb(save)? "" : "not ");
+        return false;
+    }
+    
+    if (gb->ram_size != save->ram_size) {
+        if (gb->ram_size == 0x1000 * 8 && save->ram_size == 0x2000 * 8) {
+            /* A bug in versions prior to 0.12 made CGB instances allocate twice the ammount of RAM.
+               Ignore this issue to retain compatibility with older, 0.11, save states. */
+        }
+        else {
+            GB_log(gb, "The save state has non-matching RAM size. Try changing the emulated model.\n");
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+#define READ_SECTION(gb, f, section) read_section(f, GB_GET_SECTION(gb, section), GB_SECTION_SIZE(section))
+
+int GB_load_state(GB_gameboy_t *gb, const char *path)
+{
+    GB_gameboy_t save;
+    
+    /* Every unread value should be kept the same. */
+    memcpy(&save, gb, sizeof(save));
+    /* ...Except ram size, we use it to detect old saves with incorrect ram sizes */
+    save.ram_size = 0;
+    
+    FILE *f = fopen(path, "rb");
+    if (!f) {
+        GB_log(gb, "Could not open save state: %s.\n", strerror(errno));
+        return errno;
+    }
+    
+    if (fread(GB_GET_SECTION(&save, header), 1, GB_SECTION_SIZE(header), f) != GB_SECTION_SIZE(header)) goto error;
+    if (!READ_SECTION(&save, f, core_state)) goto error;
+    if (!READ_SECTION(&save, f, dma       )) goto error;
+    if (!READ_SECTION(&save, f, mbc       )) goto error;
+    if (!READ_SECTION(&save, f, hram      )) goto error;
+    if (!READ_SECTION(&save, f, timing    )) goto error;
+    if (!READ_SECTION(&save, f, apu       )) goto error;
+    if (!READ_SECTION(&save, f, rtc       )) goto error;
+    if (!READ_SECTION(&save, f, video     )) goto error;
+    
+    if (save.ram_size == 0) {
+        /* Save doesn't have ram size specified, it's a pre 0.12 save state with potentially
+           incorrect RAM amount if it's a CGB instance */
+        if (GB_is_cgb(&save)) {
+            save.ram_size = 0x2000 * 8; // Incorrect RAM size
+        }
+        else {
+            save.ram_size = gb->ram_size;
+        }
+    }
+    
+    if (!verify_state_compatibility(gb, &save)) {
+        errno = -1;
+        goto error;
+    }
+    
+    if (GB_is_hle_sgb(gb)) {
+        if (!read_section(f, gb->sgb, sizeof(*gb->sgb))) goto error;
+    }
+    
+    memset(gb->mbc_ram + save.mbc_ram_size, 0xFF, gb->mbc_ram_size - save.mbc_ram_size);
+    if (fread(gb->mbc_ram, 1, save.mbc_ram_size, f) != save.mbc_ram_size) {
+        fclose(f);
+        return EIO;
+    }
+    
+    if (fread(gb->ram, 1, gb->ram_size, f) != gb->ram_size) {
+        fclose(f);
+        return EIO;
+    }
+
+    /* Fix for 0.11 save states that allocate twice the amount of RAM in CGB instances */
+    fseek(f, save.ram_size - gb->ram_size, SEEK_CUR);
+    
+    if (fread(gb->vram, 1, gb->vram_size, f) != gb->vram_size) {
+        fclose(f);
+        return EIO;
+    }
+    
+    size_t orig_ram_size = gb->ram_size;
+    memcpy(gb, &save, sizeof(save));
+    gb->ram_size = orig_ram_size;
+
+    errno = 0;
+    
+    if (gb->cartridge_type->has_rumble && gb->rumble_callback) {
+        gb->rumble_callback(gb, gb->rumble_state);
+    }
+    
+    for (unsigned i = 0; i < 32; i++) {
+        GB_palette_changed(gb, false, i * 2);
+        GB_palette_changed(gb, true, i * 2);
+    }
+
+    gb->bg_fifo.read_end &= 0xF;
+    gb->bg_fifo.write_end &= 0xF;
+    gb->oam_fifo.read_end &= 0xF;
+    gb->oam_fifo.write_end &= 0xF;
+    
+error:
+    fclose(f);
+    return errno;
+}
+
+#undef READ_SECTION
+
+/* An read-like function for buffer-copying */
+static size_t buffer_read(void *dest, size_t length, const uint8_t **buffer, size_t *buffer_length)
+{
+    if (length > *buffer_length) {
+        length = *buffer_length;
+    }
+    
+    memcpy(dest, *buffer, length);
+    *buffer += length;
+    *buffer_length -= length;
+    
+    return length;
+}
+
+static bool buffer_read_section(const uint8_t **buffer, size_t *buffer_length, void *dest, uint32_t size)
+{
+    uint32_t saved_size = 0;
+    if (buffer_read(&saved_size, sizeof(size), buffer, buffer_length) != sizeof(size)) {
+        return false;
+    }
+    
+    if (saved_size > *buffer_length) return false;
+    
+    if (saved_size <= size) {
+        if (buffer_read(dest, saved_size, buffer, buffer_length) != saved_size) {
+            return false;
+        }
+    }
+    else {
+        if (buffer_read(dest, size, buffer, buffer_length) != size) {
+            return false;
+        }
+        *buffer += saved_size - size;
+        *buffer_length -= saved_size - size;
+    }
+    
+    return true;
+}
+
+#define READ_SECTION(gb, buffer, length, section) buffer_read_section(&buffer, &length, GB_GET_SECTION(gb, section), GB_SECTION_SIZE(section))
+int GB_load_state_from_buffer(GB_gameboy_t *gb, const uint8_t *buffer, size_t length)
+{
+    GB_gameboy_t save;
+    
+    /* Every unread value should be kept the same. */
+    memcpy(&save, gb, sizeof(save));
+    
+    if (buffer_read(GB_GET_SECTION(&save, header), GB_SECTION_SIZE(header), &buffer, &length) != GB_SECTION_SIZE(header)) return -1;
+    if (!READ_SECTION(&save, buffer, length, core_state)) return -1;
+    if (!READ_SECTION(&save, buffer, length, dma       )) return -1;
+    if (!READ_SECTION(&save, buffer, length, mbc       )) return -1;
+    if (!READ_SECTION(&save, buffer, length, hram      )) return -1;
+    if (!READ_SECTION(&save, buffer, length, timing    )) return -1;
+    if (!READ_SECTION(&save, buffer, length, apu       )) return -1;
+    if (!READ_SECTION(&save, buffer, length, rtc       )) return -1;
+    if (!READ_SECTION(&save, buffer, length, video     )) return -1;
+    
+    if (!verify_state_compatibility(gb, &save)) {
+        return -1;
+    }
+    
+    if (GB_is_hle_sgb(gb)) {
+        if (!buffer_read_section(&buffer, &length, gb->sgb, sizeof(*gb->sgb))) return -1;
+    }
+    
+    memset(gb->mbc_ram + save.mbc_ram_size, 0xFF, gb->mbc_ram_size - save.mbc_ram_size);
+    if (buffer_read(gb->mbc_ram, save.mbc_ram_size, &buffer, &length) != save.mbc_ram_size) {
+        return -1;
+    }
+    
+    if (buffer_read(gb->ram, gb->ram_size, &buffer, &length) != gb->ram_size) {
+        return -1;
+    }
+    
+    if (buffer_read(gb->vram,gb->vram_size, &buffer, &length) != gb->vram_size) {
+        return -1;
+    }
+    
+    /* Fix for 0.11 save states that allocate twice the amount of RAM in CGB instances */
+    buffer += save.ram_size - gb->ram_size;
+    length -= save.ram_size - gb->ram_size;
+    
+    memcpy(gb, &save, sizeof(save));
+    
+    if (gb->cartridge_type->has_rumble && gb->rumble_callback) {
+        gb->rumble_callback(gb, gb->rumble_state);
+    }
+    
+    for (unsigned i = 0; i < 32; i++) {
+        GB_palette_changed(gb, false, i * 2);
+        GB_palette_changed(gb, true, i * 2);
+    }
+    
+    gb->bg_fifo.read_end &= 0xF;
+    gb->bg_fifo.write_end &= 0xF;
+    gb->oam_fifo.read_end &= 0xF;
+    gb->oam_fifo.write_end &= 0xF;
+    
+    return 0;
+}
+
+#undef READ_SECTION

bsnes/gb/Core/save_state.h

@@ -0,0 +1,24 @@
+/* Macros to make the GB_gameboy_t struct more future compatible when state saving */
+#ifndef save_state_h
+#define save_state_h
+#include <stddef.h>
+
+#define GB_PADDING(type, old_usage) type old_usage##__do_not_use
+
+#define GB_SECTION(name, ...) __attribute__ ((aligned (8))) struct {} name##_section_start; __VA_ARGS__; struct {} name##_section_end
+#define GB_SECTION_OFFSET(name) (offsetof(GB_gameboy_t, name##_section_start))
+#define GB_SECTION_SIZE(name) (offsetof(GB_gameboy_t, name##_section_end) - offsetof(GB_gameboy_t, name##_section_start))
+#define GB_GET_SECTION(gb, name) ((void*)&((gb)->name##_section_start))
+
+#define GB_aligned_double __attribute__ ((aligned (8))) double
+
+
+/* Public calls related to save states */
+int GB_save_state(GB_gameboy_t *gb, const char *path);
+size_t GB_get_save_state_size(GB_gameboy_t *gb);
+/* Assumes buffer is big enough to contain the save state. Use with GB_get_save_state_size(). */
+void GB_save_state_to_buffer(GB_gameboy_t *gb, uint8_t *buffer);
+
+int GB_load_state(GB_gameboy_t *gb, const char *path);
+int GB_load_state_from_buffer(GB_gameboy_t *gb, const uint8_t *buffer, size_t length);
+#endif /* save_state_h */

bsnes/gb/Core/sgb.c

@@ -0,0 +1,767 @@
+#include "gb.h"
+#include "random.h"
+#include <math.h>
+#include <assert.h>
+
+#ifndef M_PI
+  #define M_PI 3.14159265358979323846
+#endif
+
+#define INTRO_ANIMATION_LENGTH 200
+
+enum {
+    PAL01    = 0x00,
+    PAL23    = 0x01,
+    PAL03    = 0x02,
+    PAL12    = 0x03,
+    ATTR_BLK = 0x04,
+    ATTR_LIN = 0x05,
+    ATTR_DIV = 0x06,
+    PAL_SET  = 0x0A,
+    PAL_TRN  = 0x0B,
+    DATA_SND = 0x0F,
+    MLT_REQ  = 0x11,
+    CHR_TRN  = 0x13,
+    PCT_TRN  = 0x14,
+    ATTR_TRN = 0x15,
+    ATTR_SET = 0x16,
+    MASK_EN  = 0x17,
+};
+
+typedef enum {
+    MASK_DISABLED,
+    MASK_FREEZE,
+    MASK_BLACK,
+    MASK_COLOR_0,
+} mask_mode_t;
+
+typedef enum {
+    TRANSFER_LOW_TILES,
+    TRANSFER_HIGH_TILES,
+    TRANSFER_BORDER_DATA,
+    TRANSFER_PALETTES,
+    TRANSFER_ATTRIBUTES,
+} transfer_dest_t;
+
+#define SGB_PACKET_SIZE 16
+static inline void pal_command(GB_gameboy_t *gb, unsigned first, unsigned second)
+{
+    gb->sgb->effective_palettes[0] = gb->sgb->effective_palettes[4] =
+        gb->sgb->effective_palettes[8] = gb->sgb->effective_palettes[12] =
+        gb->sgb->command[1] | (gb->sgb->command[2] << 8);
+    
+    for (unsigned i = 0; i < 3; i++) {
+        gb->sgb->effective_palettes[first * 4 + i + 1] = gb->sgb->command[3 + i * 2] | (gb->sgb->command[4 + i * 2] << 8);
+    }
+    
+    for (unsigned i = 0; i < 3; i++) {
+        gb->sgb->effective_palettes[second * 4 + i + 1] = gb->sgb->command[9 + i * 2] | (gb->sgb->command[10 + i * 2] << 8);
+    }
+}
+
+static inline void load_attribute_file(GB_gameboy_t *gb, unsigned file_index)
+{
+    if (file_index > 0x2C) return;
+    uint8_t *output = gb->sgb->attribute_map;
+    for (unsigned i = 0; i < 90; i++) {
+        uint8_t byte = gb->sgb->attribute_files[file_index * 90 + i];
+        for (unsigned j = 4; j--;) {
+            *(output++) = byte >> 6;
+            byte <<= 2;
+        }
+    }
+}
+
+static void command_ready(GB_gameboy_t *gb)
+{
+    /* SGB header commands are used to send the contents of the header to the SNES CPU.
+       A header command looks like this:
+       Command ID: 0b1111xxx1, where xxx is the packet index. (e.g. F1 for [0x104, 0x112), F3 for [0x112, 0x120))
+       Checksum: Simple one byte sum for the following content bytes
+       0xE content bytes. The last command, FB, is padded with zeros, so information past the header is not sent. */
+    
+    if ((gb->sgb->command[0] & 0xF1) == 0xF1) {
+        uint8_t checksum = 0;
+        for (unsigned i = 2; i < 0x10; i++) {
+            checksum += gb->sgb->command[i];
+        }
+        if (checksum != gb->sgb->command[1]) {
+            GB_log(gb, "Failed checksum for SGB header command, disabling SGB features\n");
+            gb->sgb->disable_commands = true;
+            return;
+        }
+        if (gb->sgb->command[0] == 0xf9) {
+            if (gb->sgb->command[0xc] != 3) { // SGB Flag
+                gb->sgb->disable_commands = true;
+            }
+        }
+        else if (gb->sgb->command[0] == 0xfb) {
+            if (gb->sgb->command[0x3] != 0x33) { // Old licensee code
+                gb->sgb->disable_commands = true;
+            }
+        }
+        return;
+    }
+    
+    /* Ignore malformed commands (0 length)*/
+    if ((gb->sgb->command[0] & 7) == 0) return;
+    
+    switch (gb->sgb->command[0] >> 3) {
+        case PAL01:
+            pal_command(gb, 0, 1);
+            break;
+        case PAL23:
+            pal_command(gb, 2, 3);
+            break;
+        case PAL03:
+            pal_command(gb, 0, 3);
+            break;
+        case PAL12:
+            pal_command(gb, 1, 2);
+            break;
+        case ATTR_BLK: {
+            struct {
+                uint8_t count;
+                struct {
+                    uint8_t control;
+                    uint8_t palettes;
+                    uint8_t left, top, right, bottom;
+                } data[];
+            } *command = (void *)(gb->sgb->command + 1);
+            if (command->count > 0x12) return;
+            
+            for (unsigned i = 0; i < command->count; i++) {
+                bool inside  = command->data[i].control & 1;
+                bool middle  = command->data[i].control & 2;
+                bool outside = command->data[i].control & 4;
+                uint8_t inside_palette = command->data[i].palettes & 0x3;
+                uint8_t middle_palette = (command->data[i].palettes >> 2) & 0x3;
+                uint8_t outside_palette = (command->data[i].palettes >> 4) & 0x3;
+                
+                if (inside && !middle && !outside) {
+                    middle = true;
+                    middle_palette = inside_palette;
+                }
+                else if (outside && !middle && !inside) {
+                    middle = true;
+                    middle_palette = outside_palette;
+                }
+                
+                command->data[i].left &= 0x1F;
+                command->data[i].top &= 0x1F;
+                command->data[i].right &= 0x1F;
+                command->data[i].bottom &= 0x1F;
+                
+                for (unsigned y = 0; y < 18; y++) {
+                    for (unsigned x = 0; x < 20; x++) {
+                        if (x < command->data[i].left || x > command->data[i].right ||
+                            y < command->data[i].top  || y > command->data[i].bottom)  {
+                            if (outside) {
+                                gb->sgb->attribute_map[x + 20 * y] = outside_palette;
+                            }
+                        }
+                        else if (x > command->data[i].left && x < command->data[i].right &&
+                                 y > command->data[i].top  && y < command->data[i].bottom)  {
+                            if (inside) {
+                                gb->sgb->attribute_map[x + 20 * y] = inside_palette;
+                            }
+                        }
+                        else if(middle) {
+                            gb->sgb->attribute_map[x + 20 * y] = middle_palette;
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        case ATTR_LIN: {
+            struct {
+                uint8_t count;
+                uint8_t data[];
+            } *command = (void *)(gb->sgb->command + 1);
+            if (command->count > sizeof(gb->sgb->command) - 2) return;
+            
+            for (unsigned i = 0; i < command->count; i++) {
+                bool horizontal = command->data[i] & 0x80;
+                uint8_t palette = (command->data[i] >> 5) & 0x3;
+                uint8_t line = (command->data[i]) & 0x1F;
+                
+                if (horizontal) {
+                    if (line > 18) continue;
+                    for (unsigned x = 0; x < 20; x++) {
+                        gb->sgb->attribute_map[x + 20 * line] = palette;
+                    }
+                }
+                else {
+                    if (line > 20) continue;
+                    for (unsigned y = 0; y < 18; y++) {
+                        gb->sgb->attribute_map[line + 20 * y] = palette;
+                    }
+                }
+            }
+            break;
+        }
+        case ATTR_DIV: {
+            uint8_t high_palette = gb->sgb->command[1] & 3;
+            uint8_t low_palette = (gb->sgb->command[1] >> 2) & 3;
+            uint8_t middle_palette = (gb->sgb->command[1] >> 4) & 3;
+            bool horizontal = gb->sgb->command[1] & 0x40;
+            uint8_t line = gb->sgb->command[2] & 0x1F;
+            
+            for (unsigned y = 0; y < 18; y++) {
+                for (unsigned x = 0; x < 20; x++) {
+                    if ((horizontal? y : x) < line) {
+                        gb->sgb->attribute_map[x + 20 * y] = low_palette;
+                    }
+                    else if ((horizontal? y : x) == line) {
+                        gb->sgb->attribute_map[x + 20 * y] = middle_palette;
+                    }
+                    else {
+                        gb->sgb->attribute_map[x + 20 * y] = high_palette;
+                    }
+                }
+            }
+
+            break;
+        }
+        case PAL_SET:
+            memcpy(&gb->sgb->effective_palettes[0],
+                   &gb->sgb->ram_palettes[4 * (gb->sgb->command[1] + (gb->sgb->command[2] & 1) * 0x100)],
+                   8);
+            memcpy(&gb->sgb->effective_palettes[4],
+                   &gb->sgb->ram_palettes[4 * (gb->sgb->command[3] + (gb->sgb->command[4] & 1) * 0x100)],
+                   8);
+            memcpy(&gb->sgb->effective_palettes[8],
+                   &gb->sgb->ram_palettes[4 * (gb->sgb->command[5] + (gb->sgb->command[6] & 1) * 0x100)],
+                   8);
+            memcpy(&gb->sgb->effective_palettes[12],
+                   &gb->sgb->ram_palettes[4 * (gb->sgb->command[7] + (gb->sgb->command[8] & 1) * 0x100)],
+                   8);
+            
+            gb->sgb->effective_palettes[12] = gb->sgb->effective_palettes[8] =
+            gb->sgb->effective_palettes[4] = gb->sgb->effective_palettes[0];
+            
+            if (gb->sgb->command[9] & 0x80) {
+                load_attribute_file(gb, gb->sgb->command[9] & 0x3F);
+            }
+            
+            if (gb->sgb->command[9] & 0x40) {
+                gb->sgb->mask_mode = MASK_DISABLED;
+            }
+            break;
+        case PAL_TRN:
+            gb->sgb->vram_transfer_countdown = 2;
+            gb->sgb->transfer_dest = TRANSFER_PALETTES;
+            break;
+        case DATA_SND:
+            // Not supported, but used by almost all SGB games for hot patching, so let's mute the warning for this
+            break;
+        case MLT_REQ:
+            gb->sgb->player_count = (uint8_t[]){1, 2, 1, 4}[gb->sgb->command[1] & 3];
+            gb->sgb->current_player = gb->sgb->player_count - 1;
+            break;
+        case CHR_TRN:
+            gb->sgb->vram_transfer_countdown = 2;
+            gb->sgb->transfer_dest = (gb->sgb->command[1] & 1)? TRANSFER_HIGH_TILES : TRANSFER_LOW_TILES;
+            break;
+        case PCT_TRN:
+            gb->sgb->vram_transfer_countdown = 2;
+            gb->sgb->transfer_dest = TRANSFER_BORDER_DATA;
+            break;
+        case ATTR_TRN:
+            gb->sgb->vram_transfer_countdown = 2;
+            gb->sgb->transfer_dest = TRANSFER_ATTRIBUTES;
+            break;
+        case ATTR_SET:
+            load_attribute_file(gb, gb->sgb->command[0] & 0x3F);
+            
+            if (gb->sgb->command[0] & 0x40) {
+                gb->sgb->mask_mode = MASK_DISABLED;
+            }
+            break;
+        case MASK_EN:
+            gb->sgb->mask_mode = gb->sgb->command[1] & 3;
+            break;
+        default:
+            if ((gb->sgb->command[0] >> 3) == 8 &&
+                (gb->sgb->command[1] & ~0x80) == 0  &&
+                (gb->sgb->command[2] & ~0x80) == 0) {
+                /* Mute/dummy sound commands, ignore this command as it's used by many games at startup */
+                break;
+            }
+            GB_log(gb, "Unimplemented SGB command %x: ", gb->sgb->command[0] >> 3);
+            for (unsigned i = 0; i < gb->sgb->command_write_index / 8; i++) {
+                GB_log(gb, "%02x ", gb->sgb->command[i]);
+            }
+            GB_log(gb, "\n");
+    }
+}
+
+void GB_sgb_write(GB_gameboy_t *gb, uint8_t value)
+{
+    if (gb->joyp_write_callback) {
+        gb->joyp_write_callback(gb, value);
+    }
+    if (!GB_is_sgb(gb)) return;
+    if (!GB_is_hle_sgb(gb)) {
+        /* Notify via callback */
+        return;
+    }
+    if (gb->sgb->disable_commands) return;
+    if (gb->sgb->command_write_index >= sizeof(gb->sgb->command) * 8) return;
+    
+    uint16_t command_size = (gb->sgb->command[0] & 7 ?: 1) * SGB_PACKET_SIZE * 8;
+    if ((gb->sgb->command[0] & 0xF1) == 0xF1) {
+        command_size = SGB_PACKET_SIZE * 8;
+    }
+    
+    switch ((value >> 4) & 3) {
+        case 3:
+            gb->sgb->ready_for_pulse = true;
+            /* TODO: This is the logic used by BGB which *should* work for most/all games, but a proper test ROM is needed */
+            if (gb->sgb->player_count > 1 && (gb->io_registers[GB_IO_JOYP] & 0x30) == 0x10) {
+                gb->sgb->current_player++;
+                gb->sgb->current_player &= gb->sgb->player_count - 1;
+            }
+            break;
+            
+        case 2: // Zero
+            if (!gb->sgb->ready_for_pulse || !gb->sgb->ready_for_write) return;
+            if (gb->sgb->ready_for_stop) {
+                if (gb->sgb->command_write_index == command_size) {
+                    command_ready(gb);
+                    gb->sgb->command_write_index = 0;
+                    memset(gb->sgb->command, 0, sizeof(gb->sgb->command));
+                }
+                gb->sgb->ready_for_pulse = false;
+                gb->sgb->ready_for_write = false;
+                gb->sgb->ready_for_stop = false;
+            }
+            else {
+                gb->sgb->command_write_index++;
+                gb->sgb->ready_for_pulse = false;
+                if (((gb->sgb->command_write_index) & (SGB_PACKET_SIZE * 8 - 1)) == 0) {
+                    gb->sgb->ready_for_stop = true;
+                }
+            }
+            break;
+        case 1: // One
+            if (!gb->sgb->ready_for_pulse || !gb->sgb->ready_for_write) return;
+            if (gb->sgb->ready_for_stop) {
+                GB_log(gb, "Corrupt SGB command.\n");
+                gb->sgb->ready_for_pulse = false;
+                gb->sgb->ready_for_write = false;
+                gb->sgb->command_write_index = 0;
+                memset(gb->sgb->command, 0, sizeof(gb->sgb->command));
+            }
+            else {
+                gb->sgb->command[gb->sgb->command_write_index / 8] |= 1 << (gb->sgb->command_write_index & 7);
+                gb->sgb->command_write_index++;
+                gb->sgb->ready_for_pulse = false;
+                if (((gb->sgb->command_write_index) & (SGB_PACKET_SIZE * 8 - 1)) == 0) {
+                    gb->sgb->ready_for_stop = true;
+                }
+            }
+            break;
+        
+        case 0:
+            if (!gb->sgb->ready_for_pulse) return;
+            gb->sgb->ready_for_write = true;
+            gb->sgb->ready_for_pulse = false;
+            if (((gb->sgb->command_write_index) & (SGB_PACKET_SIZE * 8 - 1)) != 0 ||
+                gb->sgb->command_write_index == 0 ||
+                gb->sgb->ready_for_stop) {
+                gb->sgb->command_write_index = 0;
+                memset(gb->sgb->command, 0, sizeof(gb->sgb->command));
+                gb->sgb->ready_for_stop = false;
+            }
+            break;
+            
+        default:
+            break;
+    }
+}
+
+static inline uint8_t scale_channel(uint8_t x)
+{
+    return (x << 3) | (x >> 2);
+}
+
+static uint32_t convert_rgb15(GB_gameboy_t *gb, uint16_t color)
+{
+    uint8_t r = (color) & 0x1F;
+    uint8_t g = (color >> 5) & 0x1F;
+    uint8_t b = (color >> 10) & 0x1F;
+    
+    r = scale_channel(r);
+    g = scale_channel(g);
+    b = scale_channel(b);
+    
+    return gb->rgb_encode_callback(gb, r, g, b);
+}
+
+static uint32_t convert_rgb15_with_fade(GB_gameboy_t *gb, uint16_t color, uint8_t fade)
+{
+    uint8_t r = ((color) & 0x1F) - fade;
+    uint8_t g = ((color >> 5) & 0x1F) - fade;
+    uint8_t b = ((color >> 10) & 0x1F) - fade;
+    
+    if (r >= 0x20) r = 0;
+    if (g >= 0x20) g = 0;
+    if (b >= 0x20) b = 0;
+    
+    r = scale_channel(r);
+    g = scale_channel(g);
+    b = scale_channel(b);
+    
+    return gb->rgb_encode_callback(gb, r, g, b);
+}
+
+#include <stdio.h>
+static void render_boot_animation (GB_gameboy_t *gb)
+{
+#include "sgb_animation_logo.inc"
+    uint32_t *output = &gb->screen[48 + 40 * 256];
+    uint8_t *input = animation_logo;
+    unsigned fade_blue = 0;
+    unsigned fade_red = 0;
+    if (gb->sgb->intro_animation < 80 - 32) {
+        fade_blue = 32;
+    }
+    else if (gb->sgb->intro_animation < 80) {
+        fade_blue = 80 - gb->sgb->intro_animation;
+    }
+    else if (gb->sgb->intro_animation > INTRO_ANIMATION_LENGTH - 32) {
+        fade_red = fade_blue = gb->sgb->intro_animation - INTRO_ANIMATION_LENGTH + 32;
+    }
+    uint32_t colors[] = {
+        convert_rgb15(gb, 0),
+        convert_rgb15_with_fade(gb, 0x14A5, fade_blue),
+        convert_rgb15_with_fade(gb, 0x54E0, fade_blue),
+        convert_rgb15_with_fade(gb, 0x0019, fade_red),
+        convert_rgb15(gb, 0x0011),
+        convert_rgb15(gb, 0x0009),
+    };
+    unsigned y_min = (144 - animation_logo_height) / 2;
+    unsigned y_max = y_min + animation_logo_height;
+    for (unsigned y = 0; y < 144; y++) {
+        for (unsigned x = 0; x < 160; x++) {
+            if (y < y_min || y >= y_max) {
+                *(output++) = colors[0];
+            }
+            else {
+                uint8_t color = *input;
+                if (color >= 3) {
+                    if (color == gb->sgb->intro_animation / 2 - 3) {
+                        color = 5;
+                    }
+                    else if (color == gb->sgb->intro_animation / 2 - 4) {
+                        color = 4;
+                    }
+                    else if (color < gb->sgb->intro_animation / 2 - 4) {
+                        color = 3;
+                    }
+                    else {
+                        color = 0;
+                    }
+                }
+                *(output++) = colors[color];
+                input++;
+            }
+        }
+        output += 256 - 160;
+    }
+}
+
+static void render_jingle(GB_gameboy_t *gb, size_t count);
+void GB_sgb_render(GB_gameboy_t *gb)
+{
+    if (gb->apu_output.sample_rate) {
+        render_jingle(gb, gb->apu_output.sample_rate / GB_get_usual_frame_rate(gb));
+    }
+    
+    if (gb->sgb->intro_animation < INTRO_ANIMATION_LENGTH) gb->sgb->intro_animation++;
+
+    if (!gb->screen || !gb->rgb_encode_callback) return;
+    
+    if (gb->sgb->mask_mode != MASK_FREEZE) {
+        memcpy(gb->sgb->effective_screen_buffer,
+               gb->sgb->screen_buffer,
+               sizeof(gb->sgb->effective_screen_buffer));
+    }
+    
+    if (gb->sgb->vram_transfer_countdown) {
+        if (--gb->sgb->vram_transfer_countdown == 0) {
+            if (gb->sgb->transfer_dest == TRANSFER_LOW_TILES || gb->sgb->transfer_dest == TRANSFER_HIGH_TILES) {
+                uint8_t *base = &gb->sgb->pending_border.tiles[gb->sgb->transfer_dest == TRANSFER_HIGH_TILES ? 0x80 * 8 * 8 : 0];
+                for (unsigned tile = 0; tile < 0x80; tile++) {
+                    unsigned tile_x = (tile % 10) * 16;
+                    unsigned tile_y = (tile / 10) * 8;
+                    for (unsigned y = 0; y < 0x8; y++) {
+                        for (unsigned x = 0; x < 0x8; x++) {
+                            base[tile * 8 * 8 + y * 8 + x] = gb->sgb->screen_buffer[(tile_x + x) + (tile_y + y) * 160] +
+                                                             gb->sgb->screen_buffer[(tile_x + x + 8) + (tile_y + y) * 160] * 4;
+                        }
+                    }
+                }
+                
+            }
+            else {
+                unsigned size = 0;
+                uint16_t *data = NULL;
+                
+                switch (gb->sgb->transfer_dest) {
+                    case TRANSFER_PALETTES:
+                        size = 0x100;
+                        data = gb->sgb->ram_palettes;
+                        break;
+                    case TRANSFER_BORDER_DATA:
+                        size = 0x88;
+                        data = gb->sgb->pending_border.raw_data;
+                        break;
+                    case TRANSFER_ATTRIBUTES:
+                        size = 0xFE;
+                        data = (uint16_t *)gb->sgb->attribute_files;
+                        break;
+                    default:
+                        return; // Corrupt state?
+                }
+                
+                for (unsigned tile = 0; tile < size; tile++) {
+                    unsigned tile_x = (tile % 20) * 8;
+                    unsigned tile_y = (tile / 20) * 8;
+                    for (unsigned y = 0; y < 0x8; y++) {
+                        static const uint16_t pixel_to_bits[4] = {0x0000, 0x0080, 0x8000, 0x8080};
+                        *data = 0;
+                        for (unsigned x = 0; x < 8; x++) {
+                            *data |= pixel_to_bits[gb->sgb->screen_buffer[(tile_x + x) + (tile_y + y) * 160] & 3] >> x;
+                        }
+#ifdef GB_BIG_ENDIAN
+                        if (gb->sgb->transfer_dest == TRANSFER_ATTRIBUTES) {
+                            *data = __builtin_bswap16(*data);
+                        }
+#endif
+                        data++;
+                    }
+                }
+                if (gb->sgb->transfer_dest == TRANSFER_BORDER_DATA) {
+                    gb->sgb->border_animation = 64;
+                }
+            }
+        }
+    }
+    
+    uint32_t colors[4 * 4];
+    for (unsigned i = 0; i < 4 * 4; i++) {
+        colors[i] = convert_rgb15(gb, gb->sgb->effective_palettes[i]);
+    }
+    
+    if (gb->sgb->intro_animation < INTRO_ANIMATION_LENGTH) {
+        render_boot_animation(gb);
+    }
+    else {
+        uint32_t *output = &gb->screen[48 + 40 * 256];
+        uint8_t *input = gb->sgb->effective_screen_buffer;
+        switch ((mask_mode_t) gb->sgb->mask_mode) {
+            case MASK_DISABLED:
+            case MASK_FREEZE: {
+                for (unsigned y = 0; y < 144; y++) {
+                    for (unsigned x = 0; x < 160; x++) {
+                        uint8_t palette = gb->sgb->attribute_map[x / 8 + y / 8 * 20] & 3;
+                        *(output++) = colors[(*(input++) & 3) + palette * 4];
+                    }
+                    output += 256 - 160;
+                }
+                break;
+            }
+            case MASK_BLACK:
+            {
+                uint32_t black = convert_rgb15(gb, 0);
+                for (unsigned y = 0; y < 144; y++) {
+                    for (unsigned x = 0; x < 160; x++) {
+                        *(output++) = black;
+                    }
+                    output += 256 - 160;
+                }
+                break;
+            }
+            case MASK_COLOR_0:
+            {
+                for (unsigned y = 0; y < 144; y++) {
+                    for (unsigned x = 0; x < 160; x++) {
+                        *(output++) = colors[0];
+                    }
+                    output += 256 - 160;
+                }
+                break;
+            }
+        }
+    }
+    
+    uint32_t border_colors[16 * 4];
+    if (gb->sgb->border_animation == 0 || gb->sgb->intro_animation < INTRO_ANIMATION_LENGTH) {
+        for (unsigned i = 0; i < 16 * 4; i++) {
+            border_colors[i] = convert_rgb15(gb, gb->sgb->border.palette[i]);
+        }
+    }
+    else if (gb->sgb->border_animation > 32) {
+        gb->sgb->border_animation--;
+        for (unsigned i = 0; i < 16 * 4; i++) {
+            border_colors[i] = convert_rgb15_with_fade(gb, gb->sgb->border.palette[i], 64 - gb->sgb->border_animation);
+        }
+    }
+    else {
+        gb->sgb->border_animation--;
+        for (unsigned i = 0; i < 16 * 4; i++) {
+            border_colors[i] = convert_rgb15_with_fade(gb, gb->sgb->border.palette[i], gb->sgb->border_animation);
+        }
+    }
+    
+    
+    if (gb->sgb->border_animation == 32) {
+        memcpy(&gb->sgb->border, &gb->sgb->pending_border, sizeof(gb->sgb->border));
+    }
+    
+    for (unsigned tile_y = 0; tile_y < 28; tile_y++) {
+        for (unsigned tile_x = 0; tile_x < 32; tile_x++) {
+            bool gb_area = false;
+            if (tile_x >= 6 && tile_x < 26 && tile_y >= 5 && tile_y < 23) {
+                gb_area = true;
+            }
+            uint16_t tile = gb->sgb->border.map[tile_x + tile_y * 32];
+            uint8_t flip_x = (tile & 0x4000)? 0x7 : 0;
+            uint8_t flip_y = (tile & 0x8000)? 0x7 : 0;
+            uint8_t palette = (tile >> 10) & 3;
+            for (unsigned y = 0; y < 8; y++) {
+                for (unsigned x = 0; x < 8; x++) {
+                    uint8_t color = gb->sgb->border.tiles[(tile & 0xFF) * 64 + (x ^ flip_x) + (y ^ flip_y) * 8] & 0xF;
+                    if (color == 0) {
+                        if (gb_area) continue;
+                        gb->screen[tile_x * 8 + x + (tile_y * 8 + y) * 0x100] = colors[0];
+                    }
+                    else {
+                        gb->screen[tile_x * 8 + x + (tile_y * 8 + y) * 0x100] = border_colors[color + palette * 16];
+                    }
+                }
+            }
+        }
+    }
+}
+
+void GB_sgb_load_default_data(GB_gameboy_t *gb)
+{
+    
+#include "sgb_border.inc"
+    
+    memcpy(gb->sgb->border.map, tilemap, sizeof(tilemap));
+    memcpy(gb->sgb->border.palette, palette, sizeof(palette));
+    
+    /* Expend tileset */
+    for (unsigned tile = 0; tile < sizeof(tiles) / 32; tile++) {
+        for (unsigned y = 0; y < 8; y++) {
+            for (unsigned x = 0; x < 8; x++) {
+                gb->sgb->border.tiles[tile * 8 * 8 + y * 8 + x] =
+                    (tiles[tile * 32 + y * 2 +  0] & (1 << (7 ^ x)) ? 1 : 0) |
+                    (tiles[tile * 32 + y * 2 +  1] & (1 << (7 ^ x)) ? 2 : 0) |
+                    (tiles[tile * 32 + y * 2 + 16] & (1 << (7 ^ x)) ? 4 : 0) |
+                    (tiles[tile * 32 + y * 2 + 17] & (1 << (7 ^ x)) ? 8 : 0);
+            }
+        }
+    }
+    
+    if (gb->model != GB_MODEL_SGB2) {
+        /* Delete the "2" */
+        gb->sgb->border.map[25 * 32 + 25] = gb->sgb->border.map[25 * 32 + 26] =
+        gb->sgb->border.map[26 * 32 + 25] = gb->sgb->border.map[26 * 32 + 26] =
+        gb->sgb->border.map[27 * 32 + 25] = gb->sgb->border.map[27 * 32 + 26] =
+        gb->sgb->border.map[0];
+        
+        /* Re-center */
+        memmove(&gb->sgb->border.map[25 * 32 + 1], &gb->sgb->border.map[25 * 32], (32 * 3 - 1) * sizeof(gb->sgb->border.map[0]));
+    }
+    gb->sgb->effective_palettes[0] = 0x639E;
+    gb->sgb->effective_palettes[1] = 0x263A;
+    gb->sgb->effective_palettes[2] = 0x10D4;
+    gb->sgb->effective_palettes[3] = 0x2866;
+}
+
+static double fm_synth(double phase)
+{
+    return (sin(phase * M_PI * 2) +
+           sin(phase * M_PI * 2 + sin(phase * M_PI * 2)) +
+           sin(phase * M_PI * 2 + sin(phase * M_PI * 3)) +
+           sin(phase * M_PI * 2 + sin(phase * M_PI * 4))) / 4;
+}
+
+static double fm_sweep(double phase)
+{
+    double ret = 0;
+    for (unsigned i = 0; i < 8; i++) {
+        ret += sin((phase * M_PI * 2 + sin(phase * M_PI * 8) / 4) * pow(1.25, i)) * (8 - i) / 36;
+    }
+    return ret;
+}
+static double random_double(void)
+{
+    return ((signed)(GB_random32() % 0x10001) - 0x8000) / (double) 0x8000;
+}
+
+static void render_jingle(GB_gameboy_t *gb, size_t count)
+{
+    const double frequencies[7] = {
+        466.16, // Bb4
+        587.33, // D5
+        698.46, // F5
+        830.61, // Ab5
+        1046.50, // C6
+        1244.51, // Eb6
+        1567.98, // G6
+    };
+    
+    assert(gb->apu_output.sample_callback);
+    
+    if (gb->sgb->intro_animation < 0) {
+        GB_sample_t sample = {0, 0};
+        for (unsigned i = 0; i < count; i++) {
+            gb->apu_output.sample_callback(gb, &sample);
+        }
+        return;
+    }
+    
+    if (gb->sgb->intro_animation >= INTRO_ANIMATION_LENGTH) return;
+    
+    signed jingle_stage = (gb->sgb->intro_animation - 64) / 3;
+    double sweep_cutoff_ratio = 2000.0 * pow(2, gb->sgb->intro_animation / 20.0) / gb->apu_output.sample_rate;
+    double sweep_phase_shift = 1000.0 * pow(2, gb->sgb->intro_animation / 40.0) / gb->apu_output.sample_rate;
+    if (sweep_cutoff_ratio > 1) {
+        sweep_cutoff_ratio = 1;
+    }
+    
+    GB_sample_t stereo;
+    for (unsigned i = 0; i < count; i++) {
+        double sample = 0;
+        for (signed f = 0; f < 7 && f < jingle_stage; f++) {
+            sample += fm_synth(gb->sgb_intro_jingle_phases[f]) *
+                      (0.75 * pow(0.5, jingle_stage - f) + 0.25) / 5.0;
+            gb->sgb_intro_jingle_phases[f] += frequencies[f] / gb->apu_output.sample_rate;
+        }
+        if (gb->sgb->intro_animation > 100) {
+            sample *= pow((INTRO_ANIMATION_LENGTH - gb->sgb->intro_animation) / (INTRO_ANIMATION_LENGTH - 100.0), 3);
+        }
+        
+        if (gb->sgb->intro_animation < 120) {
+            double next = fm_sweep(gb->sgb_intro_sweep_phase) * 0.3 + random_double() * 0.7;
+            gb->sgb_intro_sweep_phase += sweep_phase_shift;
+
+            gb->sgb_intro_sweep_previous_sample = next * (sweep_cutoff_ratio) +
+                                                  gb->sgb_intro_sweep_previous_sample * (1 - sweep_cutoff_ratio);
+            sample += gb->sgb_intro_sweep_previous_sample * pow((120 - gb->sgb->intro_animation) / 120.0, 2) * 0.8;
+        }
+        
+        stereo.left = stereo.right = sample * 0x7000;
+        gb->apu_output.sample_callback(gb, &stereo);
+    }
+    
+    return;
+}
+

bsnes/gb/Core/sgb.h

@@ -0,0 +1,60 @@
+#ifndef sgb_h
+#define sgb_h
+#include "gb_struct_def.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct GB_sgb_s GB_sgb_t;
+
+#ifdef GB_INTERNAL
+struct GB_sgb_s {
+    uint8_t command[16 * 7];
+    uint16_t command_write_index;
+    bool ready_for_pulse;
+    bool ready_for_write;
+    bool ready_for_stop;
+    bool disable_commands;
+    
+    /* Screen buffer */
+    uint8_t screen_buffer[160 * 144]; // Live image from the Game Boy
+    uint8_t effective_screen_buffer[160 * 144]; // Image actually rendered to the screen
+    
+    /* Multiplayer Input */
+    uint8_t player_count, current_player;
+    
+    /* Mask */
+    uint8_t mask_mode;
+    
+    /* Data Transfer */
+    uint8_t vram_transfer_countdown, transfer_dest;
+    
+    /* Border */
+    struct {
+        uint8_t tiles[0x100 * 8 * 8]; /* High nibble not used*/
+        union {
+            struct {
+                uint16_t map[32 * 32];
+                uint16_t palette[16 * 4];
+            };
+            uint16_t raw_data[0x440];
+        };
+    } border, pending_border;
+    uint8_t border_animation;
+    
+    /* Colorization */
+    uint16_t effective_palettes[4 * 4];
+    uint16_t ram_palettes[4 * 512];
+    uint8_t attribute_map[20 * 18];
+    uint8_t attribute_files[0xFE0];
+    
+    /* Intro */
+    int16_t intro_animation;
+};
+
+void GB_sgb_write(GB_gameboy_t *gb, uint8_t value);
+void GB_sgb_render(GB_gameboy_t *gb);
+void GB_sgb_load_default_data(GB_gameboy_t *gb);
+
+#endif
+
+#endif

bsnes/gb/Core/sgb_animation_logo.inc

@@ -0,0 +1,563 @@
+static uint8_t animation_logo[] = {
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x3, 0x3, 0x3, 0x3, 0x3, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x1, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x1, 0x3, 0x3, 0x1, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x1, 0x1, 0x1, 0x1, 0x3, 0x3, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x1, 0x3, 0x3, 0x3, 0x3, 0x3, 0x1, 0x1, 0x0, 0x0, 0x0, 0x3, 0x3, 0x3, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x3, 0x3, 0x3, 0x3, 0x3, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x3, 0x3, 0x3, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4,
+    0x4, 0x4, 0x4, 0x3, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x3, 0x3, 0x3, 0x3, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xE, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4,
+    0x4, 0x4, 0x4, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x3, 0x3, 0x3, 0x1, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xE, 0xE, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x4, 0x4,
+    0x4, 0x4, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x3, 0x3, 0x3, 0x1, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xE, 0xE, 0xE, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x4,
+    0x4, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x3, 0x3, 0x3, 0x1, 0x1, 0x0, 0x1,
+    0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x7, 0x0, 0x0, 0x1, 0x9, 0x9, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x1, 0xC, 0xC, 0xC, 0xC, 0x0, 0x0, 0x0, 0x0, 0x0, 0xE, 0xE, 0xE, 0xE, 0x1,
+    0x0, 0x0, 0xE, 0xE, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x4,
+    0x4, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x3, 0x3, 0x1, 0x1, 0x0, 0x0, 0x5,
+    0x5, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x6, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x7, 0x7, 0x7, 0x9, 0x9, 0x9, 0x9, 0x9, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0x0, 0x0, 0x0, 0x0, 0xE, 0xE, 0xE, 0xE, 0x1,
+    0x1, 0xE, 0xE, 0xE, 0xE, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x4,
+    0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x3, 0x3, 0x1, 0x0, 0x0, 0x5, 0x5,
+    0x5, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x6, 0x6, 0x6, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1,
+    0x7, 0x7, 0x7, 0x9, 0x1, 0x1, 0x1, 0x9, 0x9, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xC,
+    0xC, 0xC, 0xC, 0xC, 0x1, 0x1, 0xC, 0xC, 0x0, 0x0, 0x0, 0xE, 0xE, 0xE, 0xE, 0xE,
+    0xE, 0xE, 0xE, 0xE, 0xE, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x4,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x1, 0x1, 0x0, 0x1, 0x5, 0x5,
+    0x5, 0x1, 0x0, 0x0, 0x0, 0x0, 0x6, 0x6, 0x6, 0x6, 0x1, 0x0, 0x0, 0x0, 0x0, 0x7,
+    0x7, 0x7, 0x9, 0x1, 0x1, 0x0, 0x0, 0x9, 0x9, 0x1, 0x0, 0x0, 0x0, 0x0, 0xC, 0xC,
+    0xC, 0xC, 0x1, 0x1, 0x0, 0xC, 0xC, 0xC, 0x1, 0x0, 0x0, 0xE, 0xE, 0xE, 0xE, 0xE,
+    0xE, 0xE, 0xE, 0xE, 0xE, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x4,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x5, 0x5, 0x5,
+    0x5, 0x1, 0x0, 0x0, 0x0, 0x1, 0x6, 0x6, 0x6, 0x1, 0x1, 0x0, 0x0, 0x0, 0x7, 0x7,
+    0x7, 0x7, 0x1, 0x1, 0x0, 0x0, 0x1, 0x9, 0x9, 0x9, 0x0, 0x0, 0x0, 0x1, 0xC, 0xC,
+    0xC, 0x1, 0x1, 0x0, 0x0, 0xC, 0xC, 0xC, 0x1, 0x0, 0x0, 0x1, 0xD, 0x1, 0x1, 0x1,
+    0x1, 0xE, 0xE, 0xE, 0xE, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x4,
+    0x4, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x5, 0x5, 0x5,
+    0x1, 0x1, 0x0, 0x0, 0x0, 0x6, 0x6, 0x6, 0x6, 0x1, 0x0, 0x0, 0x0, 0x0, 0x7, 0x7,
+    0x7, 0x1, 0x1, 0x0, 0x0, 0x0, 0x9, 0x9, 0x9, 0x1, 0x0, 0x0, 0x0, 0xC, 0xC, 0xC,
+    0xC, 0x1, 0x0, 0x0, 0xC, 0xC, 0xC, 0xC, 0x1, 0x0, 0x0, 0xD, 0xD, 0x1, 0x0, 0x0,
+    0xE, 0xE, 0xF, 0xF, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4,
+    0x4, 0x4, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x5, 0x5, 0x5,
+    0x1, 0x0, 0x0, 0x0, 0x1, 0x6, 0x6, 0x6, 0x1, 0x1, 0x0, 0x0, 0x0, 0x7, 0x7, 0x7,
+    0x7, 0x1, 0x0, 0x0, 0x0, 0x0, 0x9, 0x9, 0x9, 0x1, 0x0, 0x0, 0xC, 0xC, 0xC, 0xC,
+    0x1, 0x1, 0x0, 0x1, 0xC, 0xC, 0xC, 0x1, 0x1, 0x0, 0x1, 0xD, 0x1, 0x1, 0x0, 0xF,
+    0xF, 0xF, 0xF, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4,
+    0x4, 0x4, 0x4, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x5, 0x5, 0x5, 0x1,
+    0x1, 0x0, 0x0, 0x0, 0x6, 0x6, 0x6, 0x6, 0x1, 0x0, 0x0, 0x0, 0x1, 0x7, 0x7, 0x7,
+    0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x9, 0x9, 0x9, 0x1, 0x0, 0x0, 0xC, 0xC, 0xC, 0xC,
+    0x1, 0x0, 0x1, 0xC, 0xC, 0xC, 0xC, 0x1, 0x0, 0x0, 0xD, 0xD, 0x1, 0x0, 0x1, 0xF,
+    0xF, 0xF, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x4, 0x4, 0x4, 0x4, 0x4, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x6, 0x6, 0x1, 0x1,
+    0x0, 0x0, 0x0, 0x6, 0x6, 0x6, 0x6, 0x1, 0x0, 0x0, 0x0, 0x0, 0x7, 0x7, 0x7, 0x7,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x9, 0x9, 0x9, 0x9, 0x1, 0x0, 0x1, 0xC, 0xC, 0xB, 0xB,
+    0xC, 0xC, 0xC, 0xC, 0xC, 0xC, 0x1, 0x0, 0x0, 0xD, 0xD, 0x1, 0x1, 0x0, 0xF, 0xF,
+    0xF, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x1, 0x4, 0x4, 0x4, 0x4, 0x4, 0x0, 0x0, 0x0, 0x1, 0x6, 0x6, 0x6, 0x1, 0x0,
+    0x0, 0x0, 0x1, 0x6, 0x6, 0x7, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x7, 0x7, 0x7, 0x1,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x9, 0x9, 0x9, 0x1, 0x1, 0x0, 0xC, 0xC, 0xB, 0xB, 0x1,
+    0xC, 0xC, 0xC, 0xC, 0x1, 0x1, 0x1, 0x0, 0x1, 0xD, 0x1, 0x1, 0x0, 0x1, 0xF, 0xF,
+    0xF, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x4, 0x4, 0x4, 0x4, 0x4, 0x0, 0x0, 0x6, 0x6, 0x6, 0x1, 0x1, 0x0,
+    0x0, 0x0, 0x6, 0x6, 0x7, 0x7, 0x1, 0x0, 0x0, 0x0, 0x0, 0x7, 0x7, 0x7, 0x8, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x9, 0x9, 0x9, 0x9, 0x1, 0x0, 0x0, 0xC, 0xB, 0xB, 0xB, 0x1,
+    0x0, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0xD, 0xD, 0x1, 0x0, 0x0, 0xF, 0xF, 0xF,
+    0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0xF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x5, 0x5, 0x5, 0x5, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x1, 0x4, 0x4, 0x4, 0x1, 0x0, 0x6, 0x6, 0x6, 0x1, 0x0, 0x0,
+    0x0, 0x6, 0x6, 0x7, 0x7, 0x1, 0x1, 0x0, 0x0, 0x0, 0x7, 0x7, 0x7, 0x8, 0x8, 0x1,
+    0x0, 0x0, 0x0, 0x1, 0x9, 0x9, 0xA, 0x1, 0x1, 0x0, 0xC, 0xB, 0xB, 0xB, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xD, 0xD, 0x1, 0x1, 0x0, 0x0, 0xF, 0xF, 0xF,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0xF, 0xF, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x5, 0x5, 0x5, 0x5, 0x1, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x4, 0x4, 0x1, 0x1, 0x6, 0x6, 0x6, 0x1, 0x0, 0x0,
+    0x1, 0x6, 0x7, 0x7, 0x7, 0x1, 0x0, 0x0, 0x0, 0x7, 0x7, 0x7, 0x8, 0x8, 0xA, 0x1,
+    0x0, 0x0, 0x0, 0x9, 0x9, 0xA, 0xA, 0x1, 0x0, 0x1, 0xB, 0xB, 0xB, 0xD, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xD, 0xD, 0x1, 0x1, 0x0, 0x0, 0x0, 0xF, 0xF, 0xF,
+    0x1, 0x0, 0x0, 0x0, 0xF, 0xF, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x5, 0x5, 0x5, 0x5, 0x5, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x4, 0x4, 0x1, 0x1, 0x6, 0x6, 0x1, 0x1, 0x0, 0x1,
+    0x6, 0x1, 0x7, 0x7, 0x7, 0x1, 0x0, 0x0, 0x1, 0x7, 0x7, 0x8, 0x8, 0xA, 0xA, 0x1,
+    0x0, 0x0, 0xA, 0xA, 0xA, 0xA, 0x1, 0x1, 0x0, 0xB, 0xB, 0x1, 0xD, 0xD, 0xD, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0xD, 0xD, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0xF, 0xF, 0xF,
+    0x1, 0x0, 0x0, 0x0, 0xF, 0xF, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x5, 0x5, 0x5, 0x5, 0x5,
+    0x5, 0x1, 0x0, 0x0, 0x1, 0x4, 0x4, 0x1, 0x1, 0x0, 0x6, 0x6, 0x1, 0x0, 0x1, 0x6,
+    0x1, 0x1, 0x7, 0x7, 0x7, 0x1, 0x0, 0x1, 0x7, 0x7, 0x8, 0x8, 0x1, 0x1, 0xA, 0xA,
+    0x1, 0xA, 0xA, 0xA, 0xA, 0x1, 0x1, 0xB, 0xB, 0xB, 0x1, 0x1, 0x1, 0xD, 0xD, 0x1,
+    0x0, 0x0, 0x0, 0x1, 0xD, 0xD, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xF, 0xF, 0xF,
+    0x1, 0x0, 0x1, 0xF, 0xF, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x5, 0x5, 0x5,
+    0x5, 0x5, 0x5, 0x4, 0x4, 0x4, 0x1, 0x1, 0x0, 0x0, 0x6, 0x6, 0x6, 0x6, 0x6, 0x1,
+    0x1, 0x0, 0x1, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7, 0x8, 0x8, 0x8, 0x1, 0x0, 0x1, 0xA,
+    0xA, 0xA, 0xA, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0x1, 0x1, 0x0, 0x0, 0xD, 0xD, 0xD,
+    0xD, 0xD, 0xD, 0xD, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xF, 0xF,
+    0xF, 0xF, 0xF, 0xF, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x5,
+    0x5, 0x5, 0x5, 0x5, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x6, 0x1, 0x1, 0x1,
+    0x0, 0x0, 0x0, 0x1, 0x7, 0x7, 0x7, 0x1, 0x8, 0x8, 0x8, 0x1, 0x1, 0x0, 0x0, 0x0,
+    0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0xD,
+    0xD, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1,
+    0xF, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x8, 0x8, 0x8, 0x1, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0x8, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0x8, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0x8, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x8, 0x8, 0x8, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x8, 0x8, 0x1, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x8, 0x8, 0x1, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0,
+    0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x8, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2,
+    0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2,
+    0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x1,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2,
+    0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2,
+    0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0,
+    0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x1, 0x0, 0x1, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1,
+    0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0,
+    0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0,
+    0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0,
+    0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0,
+    0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x1, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x0, 0x0,
+    0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0,
+    0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0,
+    0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0,
+    0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0,
+    0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0,
+    0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0,
+    0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0,
+    0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x0, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
+    0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1,
+    0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1,
+    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0,
+    0x0, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0,
+    0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1,
+    0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1,
+    0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
+};
+static const unsigned animation_logo_height = sizeof(animation_logo) / 160;

bsnes/gb/Core/sgb_border.inc

@@ -0,0 +1,658 @@
+static const uint16_t palette[] = {
+    0x0000, 0x0011, 0x18C6, 0x001A, 0x318C, 0x39CE, 0x5294, 0x5AD6,
+    0x739C, 0x45A8, 0x4520, 0x18A5, 0x4631, 0x2033, 0x20EC, 0x18B7
+};
+
+static const uint16_t tilemap[] = {
+    0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001,
+    0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001,
+    0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001,
+    0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001,
+    0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002,
+    0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002,
+    0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002,
+    0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002,
+    0x1001, 0x1003, 0x1004, 0x1005, 0x1005, 0x1005, 0x1005, 0x1005,
+    0x1005, 0x1005, 0x1005, 0x1005, 0x1005, 0x1005, 0x1005, 0x1005,
+    0x1005, 0x1005, 0x1005, 0x1005, 0x1005, 0x1005, 0x1005, 0x1005,
+    0x1005, 0x1005, 0x1005, 0x1005, 0x1005, 0x5004, 0x5003, 0x1001,
+    0x1001, 0x1006, 0x1007, 0x1007, 0x1007, 0x1008, 0x1009, 0x100A,
+    0x100B, 0x100C, 0x100D, 0x100E, 0x100F, 0x1010, 0x1011, 0x1012,
+    0x1013, 0x1014, 0x1015, 0x100E, 0x1016, 0x1017, 0x1018, 0x1019,
+    0x101A, 0x101B, 0x101C, 0x1007, 0x1007, 0x1007, 0x5006, 0x1001,
+    0x1001, 0x101D, 0x101E, 0x101E, 0x101E, 0x101F, 0x1020, 0x1021,
+    0x1022, 0x1023, 0x1024, 0x1025, 0x5024, 0x1026, 0x1025, 0x1025,
+    0x1027, 0x1028, 0x1029, 0x102A, 0x102B, 0x102C, 0x102D, 0x102E,
+    0x102F, 0x1030, 0x1031, 0x101E, 0x101E, 0x101E, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1034, 0x1035, 0x5034, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x8034, 0x1036, 0xC034, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0xC01D, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0x1037, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1032, 0x1038, 0x1001,
+    0x1001, 0x101D, 0x1032, 0x1032, 0x1032, 0x1033, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+    0x1000, 0x1000, 0xC033, 0x1032, 0x1032, 0x1039, 0x103A, 0x1001,
+    0x1001, 0x103B, 0x103C, 0x1032, 0x1032, 0xC03C, 0x103D, 0x103D,
+    0x103D, 0x103D, 0x103D, 0x103D, 0x103D, 0x103D, 0x103D, 0x103D,
+    0x103D, 0x103D, 0x103D, 0x103D, 0x103D, 0x103D, 0x103D, 0x103D,
+    0x103D, 0x103D, 0x103E, 0x103F, 0x1040, 0x1041, 0x1001, 0x1001,
+    0x1001, 0x1042, 0x1043, 0x1044, 0x1044, 0x1044, 0x1044, 0x1044,
+    0x1044, 0x1044, 0x1044, 0x1044, 0x1044, 0x1044, 0x1044, 0x1044,
+    0x1044, 0x1044, 0x1044, 0x1044, 0x1044, 0x1044, 0x1044, 0x1044,
+    0x1044, 0x1044, 0x1045, 0x1046, 0x1001, 0x1001, 0x1001, 0x1001,
+    0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1047, 0x1048, 0x1049,
+    0x104A, 0x104B, 0x104C, 0x104D, 0x104E, 0x104F, 0x1050, 0x1051,
+    0x1052, 0x1053, 0x1054, 0x1055, 0x1056, 0x1057, 0x1058, 0x1059,
+    0x105A, 0x105B, 0x105C, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001,
+    0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x105D, 0x105E, 0x105F,
+    0x1060, 0x1061, 0x1062, 0x1063, 0x1064, 0x1065, 0x1066, 0x1067,
+    0x1068, 0x1069, 0x106A, 0x106B, 0x106C, 0x106D, 0x106E, 0x106F,
+    0x1070, 0x1071, 0x1072, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001,
+    0x1001, 0x1001, 0x1001, 0x1001, 0x1001, 0x1073, 0x1074, 0x1075,
+    0x1076, 0x1077, 0x1078, 0x1079, 0x107A, 0x107B, 0x107C, 0x107D,
+    0x107E, 0x107F, 0x1080, 0x1081, 0x1082, 0x1083, 0x507A, 0x1084,
+    0x1001, 0x1085, 0x507A, 0x1001, 0x1001, 0x1001, 0x1001, 0x1001,
+};
+
+const uint8_t tiles[] = {
+    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, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0xFF, 0x01, 0xFE, 0x06, 0xF9, 0x08, 0xF7,
+    0x11, 0xEF, 0x22, 0xDB, 0x20, 0xDB, 0x40, 0xB7,
+    0xFF, 0x00, 0xFF, 0x00, 0xFE, 0x00, 0xF8, 0x00,
+    0xF1, 0x00, 0xE6, 0x04, 0xE4, 0x00, 0xC8, 0x00,
+    0x7F, 0x80, 0x80, 0x7F, 0x00, 0xFF, 0x7F, 0xFF,
+    0x80, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0x80, 0x00, 0x00, 0x00, 0x7F, 0x00,
+    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x40, 0xB7, 0x00, 0xEF, 0x00, 0xEF, 0x00, 0xEF,
+    0x00, 0xEF, 0x00, 0xEF, 0x00, 0xEF, 0x00, 0xEF,
+    0xC8, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00,
+    0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x03, 0xFF, 0x02, 0xFF,
+    0x02, 0xFF, 0x02, 0xFF, 0x02, 0xFF, 0x02, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00,
+    0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0xC1, 0xDD, 0x00, 0xC9,
+    0x14, 0xFF, 0x14, 0xFF, 0x14, 0xFF, 0x00, 0xC9,
+    0x00, 0x00, 0x00, 0x00, 0xE3, 0x00, 0x36, 0x22,
+    0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x36, 0x22,
+    0x00, 0xFF, 0x00, 0xFF, 0xC7, 0xDF, 0x01, 0xCF,
+    0x11, 0xFF, 0x11, 0xFF, 0x11, 0xFF, 0x01, 0xCF,
+    0x00, 0x00, 0x00, 0x00, 0xE7, 0x00, 0x31, 0x20,
+    0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x31, 0x20,
+    0x00, 0xFF, 0x00, 0xFF, 0xC2, 0xFF, 0x03, 0xFF,
+    0x02, 0xFE, 0x02, 0xFE, 0x02, 0xFF, 0x02, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0xC2, 0x00, 0x03, 0x00,
+    0x03, 0x01, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x08, 0xFF, 0x18, 0xFF,
+    0x08, 0x4E, 0x08, 0x4E, 0x09, 0x1F, 0x08, 0x1C,
+    0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x18, 0x00,
+    0xB9, 0x10, 0xB9, 0xA1, 0xE9, 0xA0, 0xEB, 0x41,
+    0x00, 0xFF, 0x00, 0xFF, 0x4F, 0xFF, 0x02, 0x1F,
+    0x02, 0x4F, 0x02, 0x4F, 0xF2, 0xFF, 0x02, 0xE7,
+    0x00, 0x00, 0x00, 0x00, 0x4F, 0x00, 0xE2, 0xA0,
+    0xB2, 0xA0, 0xB2, 0x10, 0xF2, 0x00, 0x1A, 0x10,
+    0x00, 0xFF, 0x00, 0xFF, 0xBC, 0xFD, 0x22, 0xFB,
+    0x22, 0xFB, 0x3C, 0xFD, 0x24, 0xFF, 0x26, 0xF9,
+    0x00, 0x00, 0x00, 0x00, 0xBE, 0x00, 0x26, 0x00,
+    0x26, 0x00, 0x3E, 0x00, 0x24, 0x00, 0x26, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x50, 0xFF, 0x49, 0xEF,
+    0x49, 0xF0, 0x46, 0xFF, 0x49, 0xF0, 0x49, 0xEF,
+    0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x59, 0x00,
+    0x4F, 0x06, 0x46, 0x00, 0x4F, 0x06, 0x59, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x88, 0xFF, 0x00, 0x72,
+    0x00, 0xF2, 0x05, 0xFF, 0x00, 0xF8, 0x00, 0x78,
+    0x00, 0x00, 0x00, 0x00, 0x88, 0x00, 0x8D, 0x08,
+    0x0D, 0x05, 0x05, 0x00, 0x07, 0x05, 0x87, 0x02,
+    0x00, 0xFF, 0x00, 0xFF, 0x8A, 0xFF, 0x02, 0x27,
+    0x02, 0x27, 0x52, 0xFF, 0x02, 0x8F, 0x02, 0x8F,
+    0x00, 0x00, 0x00, 0x00, 0x8A, 0x00, 0xDA, 0x88,
+    0xDA, 0x50, 0x52, 0x00, 0x72, 0x50, 0x72, 0x20,
+    0x00, 0xFF, 0x00, 0xFF, 0xFA, 0xFF, 0x22, 0xFF,
+    0x22, 0xFF, 0x23, 0xFF, 0x22, 0xFF, 0x22, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x22, 0x00,
+    0x22, 0x00, 0x23, 0x00, 0x22, 0x00, 0x22, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x20, 0xFF, 0x20, 0xFF,
+    0x20, 0xFF, 0xE0, 0xFF, 0x20, 0xFF, 0x20, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00,
+    0x20, 0x00, 0xE0, 0x00, 0x20, 0x00, 0x20, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x33, 0x37, 0x00, 0x77,
+    0x80, 0xFF, 0x20, 0x27, 0x08, 0xFF, 0x00, 0x77,
+    0x00, 0x00, 0x00, 0x00, 0xFB, 0x40, 0x88, 0x88,
+    0x80, 0x00, 0xF8, 0x50, 0x08, 0x00, 0x88, 0x88,
+    0x00, 0xFF, 0x00, 0xFF, 0xEF, 0xFF, 0x88, 0xFF,
+    0x88, 0xFF, 0x8F, 0xFF, 0x88, 0xFF, 0x88, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0xEF, 0x00, 0x88, 0x00,
+    0x88, 0x00, 0x8F, 0x00, 0x88, 0x00, 0x88, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0xF9, 0xFD, 0x80, 0xF9,
+    0x84, 0xFF, 0xF4, 0xFF, 0x84, 0xFF, 0x80, 0xF9,
+    0x00, 0x00, 0x00, 0x00, 0xFB, 0x00, 0x86, 0x02,
+    0x84, 0x00, 0xF4, 0x00, 0x84, 0x00, 0x86, 0x02,
+    0x00, 0xFF, 0x00, 0xFF, 0xC0, 0xDF, 0x00, 0xCF,
+    0x10, 0xFF, 0x10, 0xFF, 0x10, 0xFF, 0x00, 0xCF,
+    0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x30, 0x20,
+    0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x30, 0x20,
+    0x00, 0xFF, 0x00, 0xFF, 0x30, 0x36, 0x00, 0x74,
+    0x82, 0xFF, 0x22, 0x27, 0x0A, 0xFF, 0x00, 0x74,
+    0x00, 0x00, 0x00, 0x00, 0xF9, 0x40, 0x8B, 0x89,
+    0x82, 0x00, 0xFA, 0x50, 0x0A, 0x00, 0x8B, 0x89,
+    0x00, 0xFF, 0x00, 0xFF, 0xE2, 0xEF, 0x02, 0xE7,
+    0x0A, 0xFF, 0x0A, 0xFF, 0x0A, 0xFF, 0x00, 0xE4,
+    0x00, 0x00, 0x00, 0x00, 0xF2, 0x00, 0x1A, 0x10,
+    0x0A, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x1B, 0x12,
+    0x00, 0xFF, 0x00, 0xFF, 0x14, 0xFF, 0x16, 0xFF,
+    0x14, 0xFC, 0x15, 0xFE, 0x14, 0xFF, 0x04, 0xCF,
+    0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x16, 0x00,
+    0x17, 0x01, 0x15, 0x00, 0x14, 0x00, 0x34, 0x10,
+    0x00, 0xFF, 0x00, 0xFF, 0x2F, 0xFF, 0x28, 0xFF,
+    0x28, 0xFF, 0xA8, 0x7F, 0x28, 0x3F, 0x68, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x28, 0x00,
+    0x28, 0x00, 0xA8, 0x00, 0xE8, 0x80, 0x68, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0x7F, 0x00, 0x3F,
+    0x40, 0xFF, 0x40, 0xFF, 0x40, 0xFF, 0x00, 0x3F,
+    0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0xC0, 0x80,
+    0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xC0, 0x80,
+    0x00, 0xEF, 0x00, 0xEF, 0x00, 0xEF, 0x00, 0xEF,
+    0x00, 0xEF, 0x00, 0xEF, 0x00, 0xEF, 0x00, 0xEF,
+    0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00,
+    0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x03, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x01, 0xFF,
+    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0xC1, 0xDD, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xE3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0xC1, 0xDF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xE1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x02, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x4A, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x0A, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x22, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x82, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x20, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x60, 0x67, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xF8, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x8F, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x8F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0xA2, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xA2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0xF9, 0xFD, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xFB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0xC0, 0xDF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x60, 0x66, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xF9, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0xE0, 0xEE, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xF1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0xC4, 0xDF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0xE4, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x2F, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+    0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0x00, 0x7F, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x80, 0xFF,
+    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF,
+    0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF,
+    0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+    0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x3C, 0xFF,
+    0x7E, 0xFF, 0xE7, 0xE7, 0xFF, 0x7E, 0xFF, 0x7E,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x7E,
+    0x81, 0xC3, 0x00, 0x99, 0x00, 0x00, 0x00, 0x00,
+    0xFF, 0x7E, 0xFF, 0x3C, 0xFF, 0x00, 0x7E, 0x81,
+    0x3C, 0xC3, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0xC3, 0x81,
+    0x7E, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xF7, 0x00, 0xF7, 0x00, 0xF7, 0x00, 0xF7,
+    0x00, 0xF7, 0x00, 0xED, 0x00, 0xED, 0x00, 0xED,
+    0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00,
+    0x09, 0x00, 0x11, 0x02, 0x11, 0x02, 0x11, 0x02,
+    0x00, 0xED, 0x00, 0xDB, 0x00, 0xDB, 0x00, 0xDB,
+    0x00, 0xB7, 0x00, 0xB7, 0x00, 0x6F, 0x00, 0x6F,
+    0x11, 0x02, 0x23, 0x04, 0x23, 0x04, 0x23, 0x04,
+    0x47, 0x08, 0x47, 0x08, 0x8F, 0x10, 0x8F, 0x10,
+    0x00, 0xFE, 0x00, 0xFD, 0x00, 0xFB, 0x00, 0xF7,
+    0x00, 0xEE, 0x00, 0xDD, 0x00, 0xBB, 0x00, 0x77,
+    0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00,
+    0x10, 0x01, 0x21, 0x02, 0x43, 0x04, 0x87, 0x08,
+    0x00, 0xDF, 0x00, 0xBF, 0x00, 0xBF, 0x00, 0x7F,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x1F, 0x20, 0x3F, 0x40, 0x3F, 0x40, 0x7F, 0x80,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0xEF, 0x00, 0xEF, 0x00, 0xEF, 0x00, 0xB7,
+    0x00, 0xB7, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xEE,
+    0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x88, 0x40,
+    0x88, 0x40, 0xC4, 0x20, 0xC2, 0x20, 0xE1, 0x10,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x7F,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
+    0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x7F, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFC,
+    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFC, 0x00, 0xE3, 0x00, 0x1F,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x1C, 0x00, 0xE0, 0x00,
+    0x00, 0xFE, 0x00, 0xFD, 0x00, 0xF3, 0x00, 0xEF,
+    0x00, 0x1C, 0x00, 0xF3, 0x00, 0xEF, 0x00, 0x1F,
+    0x01, 0x00, 0x02, 0x00, 0x0C, 0x00, 0x10, 0x00,
+    0xE0, 0x03, 0x03, 0x0C, 0x0F, 0x10, 0x1F, 0xE0,
+    0x00, 0xEF, 0x00, 0xDF, 0x00, 0xBF, 0x00, 0x7F,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x0F, 0x10, 0x1F, 0x20, 0x3F, 0x40, 0x7F, 0x80,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0xF7, 0x00, 0xF9, 0x00, 0xFE, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xF0, 0x08, 0xF8, 0x06, 0xFE, 0x01, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0x80, 0x00, 0xFF, 0x00, 0x7F, 0x00, 0x80,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x7F, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x7F,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0x03, 0x00, 0xFF, 0x00, 0xFC, 0x00, 0x03,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFC, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0xFC,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0xFC, 0x00, 0xE3, 0x00, 0x1F, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0x03, 0x03, 0x1C, 0x1F, 0xE0, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x01, 0xFF, 0x01, 0xFD, 0x03, 0xFF, 0x03, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x01, 0xFE, 0x02, 0xFE, 0x02, 0xFC, 0x00,
+    0x0E, 0xEE, 0x3F, 0xFF, 0x75, 0x71, 0xFB, 0xE7,
+    0xE3, 0xCB, 0xC7, 0x9F, 0x07, 0x3E, 0x84, 0x7C,
+    0xFB, 0x1B, 0xE6, 0x26, 0x8E, 0x82, 0x3E, 0x22,
+    0x7C, 0x54, 0x7D, 0x25, 0xF9, 0x40, 0xFB, 0x01,
+    0x00, 0xFF, 0x00, 0xFF, 0x80, 0xFF, 0x80, 0xFF,
+    0x00, 0x7F, 0x80, 0x4F, 0x31, 0x7F, 0x71, 0xFD,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x80, 0xFF, 0x80,
+    0xFF, 0x00, 0xFF, 0x30, 0xFF, 0xB1, 0xDE, 0x52,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0x7B, 0x87, 0xFF, 0x8E, 0xFE,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x84, 0xFA, 0x82, 0xF9, 0x88,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0xC1, 0xFD, 0xE3, 0x7B,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xC3, 0xBC, 0x24,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x01, 0xFF, 0x03, 0xFF, 0xE3, 0xFB, 0xF7, 0xBF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x01, 0xFE, 0x02, 0x7C, 0x64, 0xFC, 0xB4,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0x7F, 0x80, 0xFF, 0xA0, 0x2F, 0xF0, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x80, 0xFF, 0x80, 0xFF, 0x70, 0x8F, 0x80,
+    0x00, 0xFF, 0x00, 0xFF, 0x02, 0xFD, 0x00, 0xF7,
+    0x00, 0xFF, 0x11, 0xEE, 0x11, 0xEE, 0x10, 0xEF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFC, 0x03, 0xF8, 0x0F,
+    0xF0, 0x0F, 0xE0, 0x1F, 0xE1, 0x1E, 0xE0, 0x1F,
+    0x00, 0xFF, 0x00, 0xFF, 0x10, 0xE7, 0x00, 0xFB,
+    0xC4, 0x3B, 0x98, 0x03, 0x00, 0xEF, 0x80, 0x7F,
+    0xFF, 0x00, 0xFF, 0x00, 0x0F, 0xF8, 0x07, 0xFC,
+    0x07, 0xF8, 0xEF, 0x74, 0xFF, 0x10, 0x7F, 0x80,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xEF, 0x00, 0xFF, 0x22, 0xDD, 0x06, 0xB9,
+    0xFF, 0x00, 0xFF, 0x00, 0xF8, 0x07, 0xF0, 0x0F,
+    0xF0, 0x1F, 0xE0, 0x1F, 0xC0, 0x3F, 0xC4, 0x7B,
+    0x00, 0xFF, 0x00, 0xFF, 0x80, 0x7D, 0x02, 0xFD,
+    0x02, 0xBD, 0x40, 0xBF, 0x40, 0xBF, 0x40, 0xBF,
+    0xFF, 0x00, 0xFF, 0x00, 0x7E, 0x83, 0x7C, 0x83,
+    0x7C, 0xC3, 0x7C, 0x83, 0x3C, 0xC3, 0x3C, 0xC3,
+    0x00, 0xFF, 0x00, 0xFF, 0x10, 0xEF, 0x00, 0xFF,
+    0x00, 0xF7, 0x00, 0xF7, 0x48, 0xB6, 0x48, 0xB7,
+    0xFF, 0x00, 0xFF, 0x00, 0x0F, 0xF0, 0x0F, 0xF0,
+    0x0F, 0xF8, 0x0F, 0xF8, 0x07, 0xF9, 0x06, 0xF9,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xBF, 0x02, 0xFC,
+    0x02, 0x7D, 0x02, 0xFD, 0x02, 0xFD, 0x20, 0xDD,
+    0xFF, 0x00, 0xFF, 0x00, 0xC1, 0x7E, 0x81, 0x7F,
+    0x81, 0xFE, 0x01, 0xFE, 0x03, 0xFC, 0x03, 0xFE,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xBF, 0x40, 0xBF,
+    0x47, 0xB8, 0x08, 0xF0, 0x08, 0xF7, 0x0F, 0xF0,
+    0xFF, 0x00, 0xFF, 0x00, 0xC0, 0x7F, 0x80, 0x7F,
+    0x80, 0x7F, 0x87, 0x7F, 0x87, 0x78, 0x80, 0x7F,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFB, 0x24, 0xCB,
+    0xE4, 0x1B, 0x00, 0x1F, 0x00, 0xFF, 0x80, 0x3F,
+    0xFF, 0x00, 0xFF, 0x00, 0x1C, 0xE7, 0x18, 0xF7,
+    0x18, 0xE7, 0xF8, 0xE7, 0xF8, 0x07, 0x78, 0xC7,
+    0x00, 0xFF, 0x00, 0xFF, 0x04, 0xF9, 0x00, 0xFF,
+    0x71, 0x8E, 0x89, 0x06, 0x81, 0x7E, 0xE1, 0x1E,
+    0xFF, 0x00, 0xFF, 0x00, 0x03, 0xFE, 0x01, 0xFE,
+    0x00, 0xFF, 0x70, 0xFF, 0x70, 0x8F, 0x01, 0xFE,
+    0x00, 0xFF, 0x00, 0xFF, 0x02, 0xF9, 0x00, 0xFF,
+    0x00, 0xFF, 0x03, 0xFC, 0x06, 0xB9, 0x44, 0xBB,
+    0xFF, 0x00, 0xFF, 0x00, 0xFC, 0x07, 0xF0, 0x0F,
+    0xE0, 0x1F, 0xC1, 0x3E, 0xC3, 0x7C, 0x87, 0x78,
+    0x00, 0xFF, 0x00, 0xFF, 0x08, 0xF7, 0x00, 0xFD,
+    0xC0, 0x3F, 0x11, 0x0E, 0x00, 0xFF, 0x08, 0xF7,
+    0xFF, 0x00, 0xFF, 0x00, 0x07, 0xF8, 0x03, 0xFE,
+    0x01, 0xFE, 0xE0, 0xFF, 0xF0, 0x0F, 0xF0, 0x0F,
+    0x00, 0xFF, 0x00, 0xFF, 0x08, 0x77, 0x40, 0xBF,
+    0x04, 0xBB, 0x00, 0xFE, 0x00, 0xDD, 0x00, 0x7F,
+    0xFF, 0x00, 0xFF, 0x00, 0x87, 0xF8, 0x87, 0x78,
+    0xC3, 0x7C, 0xC3, 0x3D, 0xE2, 0x3F, 0xE0, 0x9F,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFD, 0x06, 0xF9,
+    0x0C, 0x73, 0x08, 0xF7, 0x10, 0xE7, 0x20, 0xCF,
+    0xFF, 0x00, 0xFF, 0x00, 0xC3, 0x3E, 0x83, 0x7C,
+    0x87, 0xF8, 0x0F, 0xF0, 0x1F, 0xE8, 0x3F, 0xD0,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xF7, 0x00, 0xFF,
+    0x01, 0xDE, 0x06, 0xF8, 0x1C, 0xC3, 0x00, 0xF3,
+    0xFF, 0x00, 0xFF, 0x00, 0xF8, 0x0F, 0xE0, 0x1F,
+    0xE0, 0x3F, 0xC3, 0x3D, 0xE7, 0x38, 0xFF, 0x0C,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xDF, 0x00, 0xFF,
+    0x00, 0xF7, 0x08, 0x77, 0x08, 0xF7, 0x08, 0xF7,
+    0xFF, 0x00, 0xFF, 0x00, 0x3F, 0xE0, 0x0F, 0xF0,
+    0x0F, 0xF8, 0x87, 0xF8, 0x87, 0x78, 0x07, 0xF8,
+    0x03, 0xFF, 0x03, 0xFF, 0x01, 0xFF, 0x00, 0xFE,
+    0x18, 0xDF, 0x1C, 0xFD, 0x0F, 0xEF, 0x07, 0xF7,
+    0xFC, 0x00, 0xFE, 0x02, 0xFF, 0x01, 0xFF, 0x01,
+    0xFF, 0x38, 0xF3, 0x12, 0xF9, 0x19, 0xFC, 0x0C,
+    0x02, 0x79, 0x80, 0xFD, 0xC0, 0xDF, 0xF0, 0xFE,
+    0x79, 0x3F, 0x19, 0xDB, 0x19, 0xFB, 0xF9, 0xF7,
+    0xFF, 0x84, 0xFF, 0x82, 0x7F, 0x60, 0x9F, 0x91,
+    0xEF, 0xA9, 0xF6, 0x34, 0xFE, 0x1C, 0x1F, 0x11,
+    0x63, 0xEF, 0xF3, 0xEB, 0xC6, 0xCE, 0xEF, 0xDE,
+    0x8C, 0x9C, 0xDE, 0xBD, 0x9C, 0x9D, 0xFF, 0xEF,
+    0x9E, 0x02, 0xBC, 0xA4, 0x3D, 0x14, 0x7B, 0x4A,
+    0x73, 0x21, 0xF7, 0x94, 0xF7, 0xF6, 0xFE, 0xEE,
+    0x8D, 0xEC, 0x9E, 0x7D, 0x1C, 0x5B, 0x38, 0xFA,
+    0x79, 0xF7, 0x71, 0x75, 0xF3, 0xF3, 0xEF, 0xCF,
+    0xF3, 0x90, 0xF7, 0x14, 0xEF, 0xA8, 0xEF, 0x2D,
+    0xCF, 0x41, 0x8E, 0x8A, 0x3C, 0x3C, 0x39, 0x19,
+    0x67, 0xFF, 0xEF, 0xFE, 0xEC, 0xDC, 0xCF, 0xCF,
+    0xDD, 0xDC, 0xDC, 0x9F, 0x2C, 0x2F, 0xD7, 0xC7,
+    0xB9, 0x21, 0xBB, 0xAA, 0xB3, 0x81, 0x76, 0x76,
+    0x77, 0x76, 0xE7, 0xA4, 0xD7, 0x44, 0xFB, 0xCB,
+    0xB3, 0x37, 0x73, 0x72, 0xF4, 0xEC, 0xEF, 0xCD,
+    0xCD, 0x09, 0x11, 0xF3, 0x29, 0xA7, 0xF1, 0xCF,
+    0xCD, 0x49, 0xDF, 0xDE, 0xBF, 0xA5, 0x7F, 0x5D,
+    0xF6, 0x32, 0xFE, 0x14, 0xFE, 0x70, 0xFF, 0xC1,
+    0xF0, 0x77, 0xF0, 0x67, 0xE0, 0xCF, 0x80, 0x97,
+    0xC8, 0xBB, 0x98, 0xBB, 0x90, 0xD3, 0xE8, 0xE7,
+    0xDF, 0x58, 0xBF, 0x28, 0x7F, 0x50, 0x7F, 0x28,
+    0xF7, 0x84, 0xFF, 0xDC, 0xEF, 0xA4, 0xDF, 0xC0,
+    0x00, 0xFF, 0x04, 0xF3, 0x03, 0xF8, 0x00, 0xFF,
+    0x08, 0xF7, 0x03, 0xFC, 0x00, 0xBF, 0x18, 0xC7,
+    0xF0, 0x0F, 0xF8, 0x0F, 0xFE, 0x05, 0xFF, 0x00,
+    0xE7, 0x18, 0xC0, 0x3F, 0xC0, 0x7F, 0xE0, 0x3F,
+    0x00, 0xFF, 0x00, 0xFF, 0x08, 0xF6, 0x08, 0x77,
+    0x08, 0xF5, 0x08, 0xF7, 0x10, 0xE7, 0x70, 0x87,
+    0x1F, 0xE0, 0x0F, 0xF0, 0x07, 0xF9, 0x86, 0xF9,
+    0x86, 0x7B, 0x0C, 0xF3, 0x08, 0xFF, 0x38, 0xCF,
+    0x0A, 0xF1, 0x88, 0x77, 0x0E, 0xF1, 0x00, 0xFF,
+    0x00, 0xFF, 0x7F, 0x80, 0x41, 0xBE, 0x81, 0x3E,
+    0x84, 0x7F, 0x0E, 0xF1, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x3E, 0xC1, 0x7E, 0x81, 0x7E, 0xC1,
+    0x04, 0xFB, 0x04, 0xDB, 0x24, 0xDB, 0x20, 0xDF,
+    0x20, 0xDF, 0x00, 0xFF, 0x08, 0xE7, 0x19, 0xE6,
+    0x38, 0xC7, 0x38, 0xE7, 0x38, 0xC7, 0x18, 0xE7,
+    0x18, 0xE7, 0x18, 0xE7, 0x10, 0xFF, 0x10, 0xEF,
+    0x48, 0xB5, 0x80, 0x3F, 0x84, 0x7B, 0x80, 0x7F,
+    0xA1, 0x5E, 0x21, 0x5E, 0x02, 0x7C, 0x02, 0x7D,
+    0x46, 0xBB, 0x44, 0xFB, 0x40, 0xBF, 0x40, 0xBF,
+    0xC0, 0x3F, 0xC1, 0xBE, 0xE1, 0x9F, 0xE3, 0x9C,
+    0x60, 0x9D, 0x64, 0x99, 0x84, 0x3B, 0x84, 0x7B,
+    0x04, 0x7B, 0x40, 0xBB, 0x41, 0xBA, 0x09, 0xF2,
+    0x03, 0xFE, 0x43, 0xBE, 0x43, 0xFC, 0xC3, 0x3C,
+    0xC7, 0xB8, 0x87, 0x7C, 0x86, 0x7D, 0x86, 0x7D,
+    0x80, 0x7F, 0x80, 0x7F, 0x8F, 0x70, 0x10, 0xEF,
+    0x10, 0xEF, 0x1F, 0xE0, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x0F, 0xF0, 0x0F, 0xF0,
+    0x0F, 0xF0, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x48, 0xB7, 0x48, 0xB7, 0xC0, 0x3F, 0x01, 0xFE,
+    0x01, 0xFE, 0x81, 0x2E, 0x50, 0xAF, 0x50, 0xAF,
+    0x30, 0xCF, 0x30, 0xCF, 0xF0, 0x0F, 0xF0, 0x0F,
+    0xF0, 0x0F, 0x70, 0xDF, 0x20, 0xDF, 0x60, 0x9F,
+    0x06, 0xF8, 0x00, 0xFD, 0xF0, 0x0F, 0x00, 0x7E,
+    0x00, 0xEE, 0xE2, 0x1C, 0x02, 0xFD, 0x0C, 0xF1,
+    0x03, 0xFD, 0x03, 0xFE, 0xE1, 0x1E, 0xF1, 0x8F,
+    0xF1, 0x1F, 0x01, 0xFF, 0x03, 0xFC, 0x07, 0xFA,
+    0x08, 0xF3, 0x08, 0xF7, 0x08, 0xF7, 0x00, 0xFF,
+    0x40, 0xBB, 0x01, 0xFE, 0x20, 0xDF, 0x18, 0xE7,
+    0x87, 0x7C, 0x87, 0x78, 0x87, 0x78, 0x87, 0x78,
+    0x87, 0x7C, 0xC0, 0x3F, 0xE0, 0x1F, 0xF0, 0x0F,
+    0x08, 0xF7, 0x08, 0xF7, 0x01, 0xFE, 0x11, 0xEE,
+    0x01, 0xDE, 0x82, 0x7C, 0x04, 0xF9, 0x38, 0xC3,
+    0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xE0, 0x1F,
+    0xE1, 0x3E, 0x03, 0xFD, 0x07, 0xFA, 0x0F, 0xF4,
+    0x10, 0x6F, 0x00, 0x7F, 0x01, 0x7E, 0x01, 0xFE,
+    0x01, 0xFE, 0x11, 0xEE, 0x10, 0xEE, 0x12, 0xEC,
+    0xE0, 0x9F, 0xF0, 0x8F, 0xF0, 0x8F, 0xF0, 0x0F,
+    0xF0, 0x0F, 0xE1, 0x1E, 0xE1, 0x1F, 0xE1, 0x1F,
+    0x40, 0x9F, 0x80, 0x3F, 0x80, 0x7F, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x7F, 0xA0, 0x7F, 0xC0, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x00, 0xFF, 0x00, 0xFB, 0x08, 0xF7, 0x00, 0xFF,
+    0x01, 0xBE, 0x03, 0xFC, 0x00, 0x7F, 0x80, 0x7F,
+    0xFE, 0x01, 0xFC, 0x07, 0xF0, 0x0F, 0xE0, 0x1F,
+    0xC1, 0x7E, 0x80, 0x7F, 0x80, 0xFF, 0x00, 0xFF,
+    0x08, 0xF7, 0x10, 0xE7, 0x60, 0x8F, 0xC0, 0x3F,
+    0x80, 0x7F, 0xE0, 0x0F, 0x00, 0xEF, 0x00, 0xEF,
+    0x0F, 0xF0, 0x1F, 0xE8, 0x3F, 0xD0, 0x7F, 0x80,
+    0xFF, 0x00, 0x1F, 0xF0, 0x1F, 0xF0, 0x1F, 0xF0,
+    0x02, 0xF8, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x04, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xD0, 0xC6, 0x00, 0x1F, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0xC9, 0xFF, 0xE0, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xE7, 0x86, 0x01, 0x39, 0x01, 0xFF, 0x03, 0xFF,
+    0x03, 0xFF, 0x00, 0xFC, 0x00, 0xFE, 0x00, 0xFF,
+    0xFF, 0x9E, 0xFF, 0xC7, 0xFE, 0x00, 0xFE, 0x02,
+    0xFF, 0x03, 0xFF, 0x02, 0xFF, 0x01, 0xFF, 0x00,
+    0xC3, 0xD3, 0xC0, 0xBC, 0x80, 0xBF, 0x00, 0x7F,
+    0x80, 0x7F, 0x00, 0x7F, 0x00, 0xFF, 0x00, 0xFF,
+    0x7F, 0x6B, 0x7F, 0x03, 0xFF, 0xC0, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x80, 0xFF, 0x00, 0xFF, 0x00,
+    0xC7, 0x1B, 0x00, 0x7C, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x23, 0xFF, 0x83, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xC0, 0x1F, 0x00, 0x7F, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x20, 0xFF, 0x80, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x50, 0x4F, 0x00, 0x9F, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x40, 0xFF, 0x60, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x07, 0xF0, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x08, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xC7, 0x18, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x20, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x80, 0x7F, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xF7, 0x08, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x0C, 0xE1, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x12, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x38, 0x87, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x40, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x8F, 0x30, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x40, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xF0, 0x07, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x08, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x03, 0xF0, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x0C, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x0E, 0xF1, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0x7F, 0x80, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+    0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00
+};

bsnes/gb/Core/sm83_cpu.h

@@ -0,0 +1,11 @@
+#ifndef sm83_cpu_h
+#define sm83_cpu_h
+#include "gb_struct_def.h"
+#include <stdint.h>
+
+void GB_cpu_disassemble(GB_gameboy_t *gb, uint16_t pc, uint16_t count);
+#ifdef GB_INTERNAL
+void GB_cpu_run(GB_gameboy_t *gb);
+#endif
+
+#endif /* sm83_cpu_h */

bsnes/gb/Core/sm83_disassembler.c

@@ -0,0 +1,788 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include "gb.h"
+
+
+typedef void GB_opcode_t(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc);
+
+static void ill(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, ".BYTE $%02x\n", opcode);
+    (*pc)++;
+}
+
+static void nop(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "NOP\n");
+    (*pc)++;
+}
+
+static void stop(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint8_t next = GB_read_memory(gb, (*pc)++);
+    if (next) {
+        GB_log(gb, "CORRUPTED STOP (%02x)\n", next);
+    }
+    else {
+        GB_log(gb, "STOP\n");
+    }
+}
+
+static char *register_names[] = {"af", "bc", "de", "hl", "sp"};
+
+static void ld_rr_d16(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    uint16_t value;
+    register_id = (GB_read_memory(gb, (*pc)++) >> 4) + 1;
+    value = GB_read_memory(gb, (*pc)++);
+    value |= GB_read_memory(gb, (*pc)++) << 8;
+    const char *symbol = GB_debugger_name_for_address(gb, value);
+    if (symbol) {
+        GB_log(gb, "LD %s, %s ; =$%04x\n", register_names[register_id], symbol, value);
+    }
+    else {
+        GB_log(gb, "LD %s, $%04x\n", register_names[register_id], value);
+    }
+}
+
+static void ld_drr_a(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = (GB_read_memory(gb, (*pc)++) >> 4) + 1;
+    GB_log(gb, "LD [%s], a\n", register_names[register_id]);
+}
+
+static void inc_rr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = (GB_read_memory(gb, (*pc)++) >> 4) + 1;
+    GB_log(gb, "INC %s\n", register_names[register_id]);
+}
+
+static void inc_hr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    (*pc)++;
+    register_id = ((opcode >> 4) + 1) & 0x03;
+    GB_log(gb, "INC %c\n", register_names[register_id][0]);
+
+}
+static void dec_hr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    (*pc)++;
+    register_id = ((opcode >> 4) + 1) & 0x03;
+    GB_log(gb, "DEC %c\n", register_names[register_id][0]);
+}
+
+static void ld_hr_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    (*pc)++;
+    register_id = ((opcode >> 4) + 1) & 0x03;
+    GB_log(gb, "LD %c, $%02x\n", register_names[register_id][0], GB_read_memory(gb, (*pc)++));
+}
+
+static void rlca(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "RLCA\n");
+}
+
+static void rla(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "RLA\n");
+}
+
+static void ld_da16_sp(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc){
+    uint16_t addr;
+    (*pc)++;
+    addr = GB_read_memory(gb, (*pc)++);
+    addr |= GB_read_memory(gb, (*pc)++) << 8;
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_log(gb, "LD [%s], sp ; =$%04x\n", symbol, addr);
+    }
+    else {
+        GB_log(gb, "LD [$%04x], sp\n", addr);
+    }
+}
+
+static void add_hl_rr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    (*pc)++;
+    register_id = (opcode >> 4) + 1;
+    GB_log(gb, "ADD hl, %s\n", register_names[register_id]);
+}
+
+static void ld_a_drr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = (GB_read_memory(gb, (*pc)++) >> 4) + 1;
+    GB_log(gb, "LD a, [%s]\n", register_names[register_id]);
+}
+
+static void dec_rr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = (GB_read_memory(gb, (*pc)++) >> 4) + 1;
+    GB_log(gb, "DEC %s\n", register_names[register_id]);
+}
+
+static void inc_lr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = (GB_read_memory(gb, (*pc)++) >> 4) + 1;
+
+    GB_log(gb, "INC %c\n", register_names[register_id][1]);
+}
+static void dec_lr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = (GB_read_memory(gb, (*pc)++) >> 4) + 1;
+
+    GB_log(gb, "DEC %c\n", register_names[register_id][1]);
+}
+
+static void ld_lr_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = (GB_read_memory(gb, (*pc)++) >> 4) + 1;
+
+    GB_log(gb, "LD %c, $%02x\n", register_names[register_id][1], GB_read_memory(gb, (*pc)++));
+}
+
+static void rrca(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "RRCA\n");
+    (*pc)++;
+}
+
+static void rra(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "RRA\n");
+    (*pc)++;
+}
+
+static void jr_r8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint16_t addr = *pc + (int8_t) GB_read_memory(gb, (*pc)) + 1;
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_attributed_log(gb, GB_LOG_UNDERLINE, "JR %s ; =$%04x\n", symbol, addr);
+    }
+    else {
+        GB_attributed_log(gb, GB_LOG_UNDERLINE, "JR $%04x\n", addr);
+    }
+    (*pc)++;
+}
+
+static const char *condition_code(uint8_t opcode)
+{
+    switch ((opcode >> 3) & 0x3) {
+        case 0:
+            return "nz";
+        case 1:
+            return "z";
+        case 2:
+            return "nc";
+        case 3:
+            return "c";
+    }
+
+    return NULL;
+}
+
+static void jr_cc_r8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint16_t addr = *pc + (int8_t) GB_read_memory(gb, (*pc)) + 1;
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_attributed_log(gb,  GB_LOG_DASHED_UNDERLINE, "JR %s, %s ; =$%04x\n", condition_code(opcode), symbol, addr);
+    }
+    else {
+        GB_attributed_log(gb,  GB_LOG_DASHED_UNDERLINE, "JR %s, $%04x\n", condition_code(opcode), addr);
+    }
+    (*pc)++;
+}
+
+static void daa(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "DAA\n");
+    (*pc)++;
+}
+
+static void cpl(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "CPL\n");
+    (*pc)++;
+}
+
+static void scf(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "SCF\n");
+    (*pc)++;
+}
+
+static void ccf(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "CCF\n");
+    (*pc)++;
+}
+
+static void ld_dhli_a(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "LD [hli], a\n");
+    (*pc)++;
+}
+
+static void ld_dhld_a(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "LD [hld], a\n");
+    (*pc)++;
+}
+
+static void ld_a_dhli(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "LD a, [hli]\n");
+    (*pc)++;
+}
+
+static void ld_a_dhld(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "LD a, [hld]\n");
+    (*pc)++;
+}
+
+static void inc_dhl(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "INC [hl]\n");
+    (*pc)++;
+}
+
+static void dec_dhl(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    GB_log(gb, "DEC [hl]\n");
+    (*pc)++;
+}
+
+static void ld_dhl_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "LD [hl], $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static const char *get_src_name(uint8_t opcode)
+{
+    uint8_t src_register_id;
+    uint8_t src_low;
+    src_register_id = ((opcode >> 1) + 1) & 3;
+    src_low = (opcode & 1);
+    if (src_register_id == GB_REGISTER_AF) {
+        return src_low? "a": "[hl]";
+    }
+    if (src_low) {
+        return register_names[src_register_id] + 1;
+    }
+    static const char *high_register_names[] = {"a", "b", "d", "h"};
+    return high_register_names[src_register_id];
+}
+
+static const char *get_dst_name(uint8_t opcode)
+{
+    uint8_t dst_register_id;
+    uint8_t dst_low;
+    dst_register_id = ((opcode >> 4) + 1) & 3;
+    dst_low = opcode & 8;
+    if (dst_register_id == GB_REGISTER_AF) {
+        return dst_low? "a": "[hl]";
+    }
+    if (dst_low) {
+        return register_names[dst_register_id] + 1;
+    }
+    static const char *high_register_names[] = {"a", "b", "d", "h"};
+    return high_register_names[dst_register_id];
+}
+
+static void ld_r_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "LD %s, %s\n", get_dst_name(opcode), get_src_name(opcode));
+}
+
+static void add_a_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "ADD %s\n",  get_src_name(opcode));
+}
+
+static void adc_a_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "ADC %s\n",  get_src_name(opcode));
+}
+
+static void sub_a_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "SUB %s\n",  get_src_name(opcode));
+}
+
+static void sbc_a_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "SBC %s\n",  get_src_name(opcode));
+}
+
+static void and_a_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "AND %s\n",  get_src_name(opcode));
+}
+
+static void xor_a_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "XOR %s\n",  get_src_name(opcode));
+}
+
+static void or_a_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "OR %s\n",  get_src_name(opcode));
+}
+
+static void cp_a_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "CP %s\n",  get_src_name(opcode));
+}
+
+static void halt(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "HALT\n");
+}
+
+static void ret_cc(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_attributed_log(gb,  GB_LOG_DASHED_UNDERLINE, "RET %s\n", condition_code(opcode));
+}
+
+static void pop_rr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = ((GB_read_memory(gb, (*pc)++) >> 4) + 1) & 3;
+    GB_log(gb, "POP %s\n", register_names[register_id]);
+}
+
+static void jp_cc_a16(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint16_t addr = GB_read_memory(gb, *pc) | (GB_read_memory(gb, *pc + 1) << 8);
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_attributed_log(gb, GB_LOG_DASHED_UNDERLINE, "JP %s, %s ; =$%04x\n", condition_code(opcode), symbol, addr);
+    }
+    else {
+        GB_attributed_log(gb, GB_LOG_DASHED_UNDERLINE, "JP %s, $%04x\n", condition_code(opcode), addr);
+    }
+    (*pc) += 2;
+}
+
+static void jp_a16(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint16_t addr = GB_read_memory(gb, *pc) | (GB_read_memory(gb, *pc + 1) << 8);
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_log(gb, "JP %s ; =$%04x\n", symbol, addr);
+    }
+    else {
+        GB_log(gb, "JP $%04x\n", addr);
+    }
+    (*pc) += 2;
+}
+
+static void call_cc_a16(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint16_t addr = GB_read_memory(gb, *pc) | (GB_read_memory(gb, *pc + 1) << 8);
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_log(gb, "CALL %s, %s ; =$%04x\n", condition_code(opcode), symbol, addr);
+    }
+    else {
+        GB_log(gb, "CALL %s, $%04x\n", condition_code(opcode), addr);
+    }
+    (*pc) += 2;
+}
+
+static void push_rr(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t register_id;
+    register_id = ((GB_read_memory(gb, (*pc)++) >> 4) + 1) & 3;
+    GB_log(gb, "PUSH %s\n", register_names[register_id]);
+}
+
+static void add_a_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "ADD $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static void adc_a_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "ADC $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static void sub_a_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "SUB $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static void sbc_a_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "SBC $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static void and_a_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "AND $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static void xor_a_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "XOR $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static void or_a_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "OR $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static void cp_a_d8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "CP $%02x\n", GB_read_memory(gb, (*pc)++));
+}
+
+static void rst(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "RST $%02x\n", opcode ^ 0xC7);
+
+}
+
+static void ret(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_attributed_log(gb, GB_LOG_UNDERLINE, "RET\n");
+}
+
+static void reti(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_attributed_log(gb, GB_LOG_UNDERLINE, "RETI\n");
+}
+
+static void call_a16(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint16_t addr = GB_read_memory(gb, *pc) | (GB_read_memory(gb, *pc + 1) << 8);
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_log(gb, "CALL %s ; =$%04x\n", symbol, addr);
+    }
+    else {
+        GB_log(gb, "CALL $%04x\n", addr);
+    }
+    (*pc) += 2;
+}
+
+static void ld_da8_a(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint8_t addr = GB_read_memory(gb, (*pc)++);
+    const char *symbol = GB_debugger_name_for_address(gb, 0xff00 + addr);
+    if (symbol) {
+        GB_log(gb, "LDH [%s & $FF], a ; =$%02x\n", symbol, addr);
+    }
+    else {
+        GB_log(gb, "LDH [$%02x], a\n", addr);
+    }
+}
+
+static void ld_a_da8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint8_t addr = GB_read_memory(gb, (*pc)++);
+    const char *symbol = GB_debugger_name_for_address(gb, 0xff00 + addr);
+    if (symbol) {
+        GB_log(gb, "LDH a, [%s & $FF] ; =$%02x\n", symbol, addr);
+    }
+    else {
+        GB_log(gb, "LDH a, [$%02x]\n", addr);
+    }
+}
+
+static void ld_dc_a(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "LDH [c], a\n");
+}
+
+static void ld_a_dc(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "LDH a, [c]\n");
+}
+
+static void add_sp_r8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    int8_t temp = GB_read_memory(gb, (*pc)++);
+    GB_log(gb, "ADD SP, %s$%02x\n", temp < 0? "-" : "", temp < 0? -temp : temp);
+}
+
+static void jp_hl(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "JP hl\n");
+}
+
+static void ld_da16_a(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint16_t addr = GB_read_memory(gb, *pc) | (GB_read_memory(gb, *pc + 1) << 8);
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_log(gb, "LD [%s], a ; =$%04x\n", symbol, addr);
+    }
+    else {
+        GB_log(gb, "LD [$%04x], a\n", addr);
+    }
+    (*pc) += 2;
+}
+
+static void ld_a_da16(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    uint16_t addr = GB_read_memory(gb, *pc) | (GB_read_memory(gb, *pc + 1) << 8);
+    const char *symbol = GB_debugger_name_for_address(gb, addr);
+    if (symbol) {
+        GB_log(gb, "LD a, [%s] ; =$%04x\n", symbol, addr);
+    }
+    else {
+        GB_log(gb, "LD a, [$%04x]\n", addr);
+    }
+    (*pc) += 2;
+}
+
+static void di(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "DI\n");
+}
+
+static void ei(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "EI\n");
+}
+
+static void ld_hl_sp_r8(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    int8_t temp = GB_read_memory(gb, (*pc)++);
+    GB_log(gb, "LD hl, sp, %s$%02x\n", temp < 0? "-" : "", temp < 0? -temp : temp);
+}
+
+static void ld_sp_hl(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "LD sp, hl\n");
+}
+
+static void rlc_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "RLC %s\n",  get_src_name(opcode));
+}
+
+static void rrc_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "RRC %s\n",  get_src_name(opcode));
+}
+
+static void rl_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "RL %s\n",  get_src_name(opcode));
+}
+
+static void rr_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "RR %s\n",  get_src_name(opcode));
+}
+
+static void sla_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "SLA %s\n",  get_src_name(opcode));
+}
+
+static void sra_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "SRA %s\n",  get_src_name(opcode));
+}
+
+static void srl_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "SRL %s\n",  get_src_name(opcode));
+}
+
+static void swap_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    (*pc)++;
+    GB_log(gb, "SWAP %s\n",  get_src_name(opcode));
+}
+
+static void bit_r(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    uint8_t bit;
+    (*pc)++;
+    bit = ((opcode >> 3) & 7);
+    if ((opcode & 0xC0) == 0x40) { /* Bit */
+        GB_log(gb, "BIT %s, %d\n",  get_src_name(opcode), bit);
+    }
+    else if ((opcode & 0xC0) == 0x80) { /* res */
+        GB_log(gb, "RES %s, %d\n",  get_src_name(opcode), bit);
+    }
+    else if ((opcode & 0xC0) == 0xC0) { /* set */
+        GB_log(gb, "SET %s, %d\n",  get_src_name(opcode), bit);
+    }
+}
+
+static void cb_prefix(GB_gameboy_t *gb, uint8_t opcode, uint16_t *pc)
+{
+    opcode = GB_read_memory(gb, ++*pc);
+    switch (opcode >> 3) {
+        case 0:
+            rlc_r(gb, opcode, pc);
+            break;
+        case 1:
+            rrc_r(gb, opcode, pc);
+            break;
+        case 2:
+            rl_r(gb, opcode, pc);
+            break;
+        case 3:
+            rr_r(gb, opcode, pc);
+            break;
+        case 4:
+            sla_r(gb, opcode, pc);
+            break;
+        case 5:
+            sra_r(gb, opcode, pc);
+            break;
+        case 6:
+            swap_r(gb, opcode, pc);
+            break;
+        case 7:
+            srl_r(gb, opcode, pc);
+            break;
+        default:
+            bit_r(gb, opcode, pc);
+            break;
+    }
+}
+
+static GB_opcode_t *opcodes[256] = {
+    /*  X0          X1          X2          X3          X4          X5          X6          X7                */
+    /*  X8          X9          Xa          Xb          Xc          Xd          Xe          Xf                */
+    nop,        ld_rr_d16,  ld_drr_a,   inc_rr,     inc_hr,     dec_hr,     ld_hr_d8,   rlca,       /* 0X */
+    ld_da16_sp, add_hl_rr,  ld_a_drr,   dec_rr,     inc_lr,     dec_lr,     ld_lr_d8,   rrca,
+    stop,       ld_rr_d16,  ld_drr_a,   inc_rr,     inc_hr,     dec_hr,     ld_hr_d8,   rla,        /* 1X */
+    jr_r8,      add_hl_rr,  ld_a_drr,   dec_rr,     inc_lr,     dec_lr,     ld_lr_d8,   rra,
+    jr_cc_r8,   ld_rr_d16,  ld_dhli_a,  inc_rr,     inc_hr,     dec_hr,     ld_hr_d8,   daa,        /* 2X */
+    jr_cc_r8,   add_hl_rr,  ld_a_dhli,  dec_rr,     inc_lr,     dec_lr,     ld_lr_d8,   cpl,
+    jr_cc_r8,   ld_rr_d16,  ld_dhld_a,  inc_rr,     inc_dhl,    dec_dhl,    ld_dhl_d8,  scf,        /* 3X */
+    jr_cc_r8,   add_hl_rr,  ld_a_dhld,  dec_rr,     inc_hr,     dec_hr,     ld_hr_d8,   ccf,
+    ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     /* 4X */
+    ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,
+    ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     /* 5X */
+    ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,
+    ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     /* 6X */
+    ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,
+    ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     halt,       ld_r_r,     /* 7X */
+    ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,     ld_r_r,
+    add_a_r,    add_a_r,    add_a_r,    add_a_r,    add_a_r,    add_a_r,    add_a_r,    add_a_r,    /* 8X */
+    adc_a_r,    adc_a_r,    adc_a_r,    adc_a_r,    adc_a_r,    adc_a_r,    adc_a_r,    adc_a_r,
+    sub_a_r,    sub_a_r,    sub_a_r,    sub_a_r,    sub_a_r,    sub_a_r,    sub_a_r,    sub_a_r,    /* 9X */
+    sbc_a_r,    sbc_a_r,    sbc_a_r,    sbc_a_r,    sbc_a_r,    sbc_a_r,    sbc_a_r,    sbc_a_r,
+    and_a_r,    and_a_r,    and_a_r,    and_a_r,    and_a_r,    and_a_r,    and_a_r,    and_a_r,    /* aX */
+    xor_a_r,    xor_a_r,    xor_a_r,    xor_a_r,    xor_a_r,    xor_a_r,    xor_a_r,    xor_a_r,
+    or_a_r,     or_a_r,     or_a_r,     or_a_r,     or_a_r,     or_a_r,     or_a_r,     or_a_r,     /* bX */
+    cp_a_r,     cp_a_r,     cp_a_r,     cp_a_r,     cp_a_r,     cp_a_r,     cp_a_r,     cp_a_r,
+    ret_cc,     pop_rr,     jp_cc_a16,  jp_a16,     call_cc_a16,push_rr,    add_a_d8,   rst,        /* cX */
+    ret_cc,     ret,        jp_cc_a16,  cb_prefix,  call_cc_a16,call_a16,   adc_a_d8,   rst,
+    ret_cc,     pop_rr,     jp_cc_a16,  ill,        call_cc_a16,push_rr,    sub_a_d8,   rst,        /* dX */
+    ret_cc,     reti,       jp_cc_a16,  ill,        call_cc_a16,ill,        sbc_a_d8,   rst,
+    ld_da8_a,   pop_rr,     ld_dc_a,    ill,        ill,        push_rr,    and_a_d8,   rst,        /* eX */
+    add_sp_r8,  jp_hl,      ld_da16_a,  ill,        ill,        ill,        xor_a_d8,   rst,
+    ld_a_da8,   pop_rr,     ld_a_dc,    di,         ill,        push_rr,    or_a_d8,    rst,        /* fX */
+    ld_hl_sp_r8,ld_sp_hl,   ld_a_da16,  ei,         ill,        ill,        cp_a_d8,    rst,
+};
+
+
+
+void GB_cpu_disassemble(GB_gameboy_t *gb, uint16_t pc, uint16_t count)
+{
+    const GB_bank_symbol_t *function_symbol = GB_debugger_find_symbol(gb, pc);
+
+    if (function_symbol && pc - function_symbol->addr > 0x1000) {
+        function_symbol = NULL;
+    }
+
+    if (function_symbol && pc != function_symbol->addr) {
+        GB_log(gb, "%s:\n", function_symbol->name);
+    }
+
+    uint16_t current_function = function_symbol? function_symbol->addr : 0;
+
+    while (count--) {
+        function_symbol = GB_debugger_find_symbol(gb, pc);
+        if (function_symbol && function_symbol->addr == pc) {
+            if (current_function != function_symbol->addr) {
+                GB_log(gb, "\n");
+            }
+            GB_log(gb, "%s:\n", function_symbol->name);
+        }
+        if (function_symbol) {
+            GB_log(gb, "%s%04x <+%03x>: ", pc == gb->pc? "  ->": "    ", pc, pc - function_symbol->addr);
+        }
+        else {
+            GB_log(gb, "%s%04x: ", pc == gb->pc? "  ->": "    ", pc);
+        }
+        uint8_t opcode = GB_read_memory(gb, pc);
+        opcodes[opcode](gb, opcode, &pc);
+    }
+}

bsnes/gb/Core/symbol_hash.c

@@ -0,0 +1,110 @@
+#include "gb.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+static size_t GB_map_find_symbol_index(GB_symbol_map_t *map, uint16_t addr)
+{
+    if (!map->symbols) {
+        return 0;
+    }
+    ssize_t min = 0;
+    ssize_t max = map->n_symbols;
+    while (min < max) {
+        size_t pivot = (min + max) / 2;
+        if (map->symbols[pivot].addr == addr) return pivot;
+        if (map->symbols[pivot].addr > addr) {
+            max = pivot;
+        }
+        else {
+            min = pivot + 1;
+        }
+    }
+    return (size_t) min;
+}
+
+GB_bank_symbol_t *GB_map_add_symbol(GB_symbol_map_t *map, uint16_t addr, const char *name)
+{
+    size_t index = GB_map_find_symbol_index(map, addr);
+
+    if (index < map->n_symbols && map->symbols[index].addr == addr) return NULL;
+
+    map->symbols = realloc(map->symbols, (map->n_symbols + 1) * sizeof(map->symbols[0]));
+    memmove(&map->symbols[index + 1], &map->symbols[index], (map->n_symbols - index) * sizeof(map->symbols[0]));
+    map->symbols[index].addr = addr;
+    map->symbols[index].name = strdup(name);
+    map->n_symbols++;
+    return &map->symbols[index];
+}
+
+const GB_bank_symbol_t *GB_map_find_symbol(GB_symbol_map_t *map, uint16_t addr)
+{
+    if (!map) return NULL;
+    size_t index = GB_map_find_symbol_index(map, addr);
+    if (index < map->n_symbols && map->symbols[index].addr != addr) {
+        index--;
+    }
+    if (index < map->n_symbols) {
+        return &map->symbols[index];
+    }
+    return NULL;
+}
+
+GB_symbol_map_t *GB_map_alloc(void)
+{
+    GB_symbol_map_t *map = malloc(sizeof(*map));
+    memset(map, 0, sizeof(*map));
+    return map;
+}
+
+void GB_map_free(GB_symbol_map_t *map)
+{
+    for (unsigned i = 0; i < map->n_symbols; i++) {
+        free(map->symbols[i].name);
+    }
+
+    if (map->symbols) {
+        free(map->symbols);
+    }
+
+    free(map);
+}
+
+static int hash_name(const char *name)
+{
+    int r = 0;
+    while (*name) {
+        r <<= 1;
+        if (r & 0x400) {
+            r ^= 0x401;
+        }
+        r += (unsigned char)*(name++);
+    }
+
+    return r & 0x3FF;
+}
+
+void GB_reversed_map_add_symbol(GB_reversed_symbol_map_t *map, uint16_t bank, GB_bank_symbol_t *bank_symbol)
+{
+    int hash = hash_name(bank_symbol->name);
+    GB_symbol_t *symbol = malloc(sizeof(*symbol));
+    symbol->name = bank_symbol->name;
+    symbol->addr = bank_symbol->addr;
+    symbol->bank = bank;
+    symbol->next = map->buckets[hash];
+    map->buckets[hash] = symbol;
+}
+
+const GB_symbol_t *GB_reversed_map_find_symbol(GB_reversed_symbol_map_t *map, const char *name)
+{
+    int hash = hash_name(name);
+    GB_symbol_t *symbol = map->buckets[hash];
+
+    while (symbol) {
+        if (strcmp(symbol->name, name) == 0) return symbol;
+        symbol = symbol->next;
+    }
+
+    return NULL;
+}

bsnes/gb/Core/symbol_hash.h

@@ -0,0 +1,38 @@
+#ifndef symbol_hash_h
+#define symbol_hash_h
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+typedef struct {
+    char *name;
+    uint16_t addr;
+} GB_bank_symbol_t;
+
+typedef struct GB_symbol_s {
+    struct GB_symbol_s *next;
+    const char *name;
+    uint16_t bank;
+    uint16_t addr;
+} GB_symbol_t;
+
+typedef struct {
+    GB_bank_symbol_t *symbols;
+    size_t n_symbols;
+} GB_symbol_map_t;
+
+typedef struct {
+    GB_symbol_t *buckets[0x400];
+} GB_reversed_symbol_map_t;
+
+#ifdef GB_INTERNAL
+void GB_reversed_map_add_symbol(GB_reversed_symbol_map_t *map, uint16_t bank, GB_bank_symbol_t *symbol);
+const GB_symbol_t *GB_reversed_map_find_symbol(GB_reversed_symbol_map_t *map, const char *name);
+GB_bank_symbol_t *GB_map_add_symbol(GB_symbol_map_t *map, uint16_t addr, const char *name);
+const GB_bank_symbol_t *GB_map_find_symbol(GB_symbol_map_t *map, uint16_t addr);
+GB_symbol_map_t *GB_map_alloc(void);
+void GB_map_free(GB_symbol_map_t *map);
+#endif
+
+#endif /* symbol_hash_h */

bsnes/gb/Core/timing.c

@@ -0,0 +1,294 @@
+#include "gb.h"
+#ifdef _WIN32
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0500
+#endif
+#include <windows.h>
+#else
+#include <sys/time.h>
+#endif
+
+static const unsigned GB_TAC_TRIGGER_BITS[] = {512, 8, 32, 128};
+
+#ifndef DISABLE_TIMEKEEPING
+static int64_t get_nanoseconds(void)
+{
+#ifndef _WIN32
+    struct timeval now;
+    gettimeofday(&now, NULL);
+    return (now.tv_usec) * 1000 + now.tv_sec * 1000000000L;
+#else
+    FILETIME time;
+    GetSystemTimeAsFileTime(&time);
+    return (((int64_t)time.dwHighDateTime << 32) | time.dwLowDateTime) * 100L;
+#endif
+}
+
+static void nsleep(uint64_t nanoseconds)
+{
+#ifndef _WIN32
+    struct timespec sleep = {0, nanoseconds};
+    nanosleep(&sleep, NULL);
+#else
+    HANDLE timer;
+    LARGE_INTEGER time;
+    timer = CreateWaitableTimer(NULL, true, NULL);
+    time.QuadPart = -(nanoseconds / 100L);
+    SetWaitableTimer(timer, &time, 0, NULL, NULL, false);
+    WaitForSingleObject(timer, INFINITE);
+    CloseHandle(timer);
+#endif
+}
+
+bool GB_timing_sync_turbo(GB_gameboy_t *gb)
+{
+    if (!gb->turbo_dont_skip) {
+        int64_t nanoseconds = get_nanoseconds();
+        if (nanoseconds <= gb->last_sync + (1000000000LL * LCDC_PERIOD / GB_get_clock_rate(gb))) {
+            return true;
+        }
+        gb->last_sync = nanoseconds;
+    }
+    return false;
+}
+
+void GB_timing_sync(GB_gameboy_t *gb)
+{
+    if (gb->turbo) {
+        gb->cycles_since_last_sync = 0;
+        return;
+    }
+    /* Prevent syncing if not enough time has passed.*/
+    if (gb->cycles_since_last_sync < LCDC_PERIOD / 3) return;
+
+    uint64_t target_nanoseconds = gb->cycles_since_last_sync * 1000000000LL / 2 / GB_get_clock_rate(gb); /* / 2 because we use 8MHz units */
+    int64_t nanoseconds = get_nanoseconds();
+    int64_t time_to_sleep = target_nanoseconds + gb->last_sync - nanoseconds;
+    if (time_to_sleep > 0 && time_to_sleep < LCDC_PERIOD * 1000000000LL / GB_get_clock_rate(gb)) {
+        nsleep(time_to_sleep);
+        gb->last_sync += target_nanoseconds;
+    }
+    else {
+        gb->last_sync = nanoseconds;
+    }
+
+    gb->cycles_since_last_sync = 0;
+    if (gb->update_input_hint_callback) {
+        gb->update_input_hint_callback(gb);
+    }
+}
+#else
+
+bool GB_timing_sync_turbo(GB_gameboy_t *gb)
+{
+    return false;
+}
+
+void GB_timing_sync(GB_gameboy_t *gb)
+{
+}
+
+#endif
+static void GB_ir_run(GB_gameboy_t *gb)
+{
+    if (gb->ir_queue_length == 0) return;
+    if (gb->cycles_since_input_ir_change >= gb->ir_queue[0].delay) {
+        gb->cycles_since_input_ir_change -= gb->ir_queue[0].delay;
+        gb->infrared_input = gb->ir_queue[0].state;
+        gb->ir_queue_length--;
+        memmove(&gb->ir_queue[0], &gb->ir_queue[1], sizeof(gb->ir_queue[0]) * (gb->ir_queue_length));
+    }
+}
+
+static void advance_tima_state_machine(GB_gameboy_t *gb)
+{
+    if (gb->tima_reload_state == GB_TIMA_RELOADED) {
+        gb->tima_reload_state = GB_TIMA_RUNNING;
+    }
+    else if (gb->tima_reload_state == GB_TIMA_RELOADING) {
+        gb->io_registers[GB_IO_IF] |= 4;
+        gb->tima_reload_state = GB_TIMA_RELOADED;
+    }
+}
+
+static void increase_tima(GB_gameboy_t *gb)
+{
+    gb->io_registers[GB_IO_TIMA]++;
+    if (gb->io_registers[GB_IO_TIMA] == 0) {
+        gb->io_registers[GB_IO_TIMA] = gb->io_registers[GB_IO_TMA];
+        gb->tima_reload_state = GB_TIMA_RELOADING;
+    }
+}
+
+static void GB_set_internal_div_counter(GB_gameboy_t *gb, uint32_t value)
+{
+    /* TIMA increases when a specific high-bit becomes a low-bit. */
+    value &= INTERNAL_DIV_CYCLES - 1;
+    uint32_t triggers = gb->div_counter & ~value;
+    if ((gb->io_registers[GB_IO_TAC] & 4) && (triggers & GB_TAC_TRIGGER_BITS[gb->io_registers[GB_IO_TAC] & 3])) {
+        increase_tima(gb);
+    }
+    
+    /* TODO: Can switching to double speed mode trigger an event? */
+    if (triggers & (gb->cgb_double_speed? 0x2000 : 0x1000)) {
+        GB_apu_run(gb);
+        GB_apu_div_event(gb);
+    }
+    gb->div_counter = value;
+}
+
+static void GB_timers_run(GB_gameboy_t *gb, uint8_t cycles)
+{
+    GB_STATE_MACHINE(gb, div, cycles, 1) {
+        GB_STATE(gb, div, 1);
+        GB_STATE(gb, div, 2);
+        GB_STATE(gb, div, 3);
+    }
+    
+    GB_set_internal_div_counter(gb, 0);
+main:
+    GB_SLEEP(gb, div, 1, 3);
+    while (true) {
+        advance_tima_state_machine(gb);
+        GB_set_internal_div_counter(gb, gb->div_counter + 4);
+        gb->apu.apu_cycles += 4 << !gb->cgb_double_speed;
+        GB_SLEEP(gb, div, 2, 4);
+    }
+    
+    /* Todo: This is ugly to allow compatibility with 0.11 save states. Fix me when breaking save compatibility */
+    {
+        div3:
+        /* Compensate for lack of prefetch emulation, as well as DIV's internal initial value */
+        GB_set_internal_div_counter(gb, 8);
+        goto main;
+    }
+}
+
+static void advance_serial(GB_gameboy_t *gb, uint8_t cycles)
+{
+    if (gb->serial_length == 0) {
+        gb->serial_cycles += cycles;
+        return;
+    }
+    
+    while (cycles > gb->serial_length) {
+        advance_serial(gb, gb->serial_length);
+        cycles -= gb->serial_length;
+    }
+    
+    uint16_t previous_serial_cycles = gb->serial_cycles;
+    gb->serial_cycles += cycles;
+    if ((gb->serial_cycles & gb->serial_length) != (previous_serial_cycles & gb->serial_length)) {
+        gb->serial_count++;
+        if (gb->serial_count == 8) {
+            gb->serial_length = 0;
+            gb->serial_count = 0;
+            gb->io_registers[GB_IO_SC] &= ~0x80;
+            gb->io_registers[GB_IO_IF] |= 8;
+        }
+        
+        gb->io_registers[GB_IO_SB] <<= 1;
+        
+        if (gb->serial_transfer_bit_end_callback) {
+            gb->io_registers[GB_IO_SB] |= gb->serial_transfer_bit_end_callback(gb);
+        }
+        else {
+            gb->io_registers[GB_IO_SB] |= 1;
+        }
+        
+        if (gb->serial_length) {
+            /* Still more bits to send */
+            if (gb->serial_transfer_bit_start_callback) {
+                gb->serial_transfer_bit_start_callback(gb, gb->io_registers[GB_IO_SB] & 0x80);
+            }
+        }
+        
+    }
+    return;
+    
+}
+
+void GB_advance_cycles(GB_gameboy_t *gb, uint8_t cycles)
+{   
+    // Affected by speed boost
+    gb->dma_cycles += cycles;
+
+    if (!gb->stopped) {
+        GB_timers_run(gb, cycles);
+        advance_serial(gb, cycles); // TODO: Verify what happens in STOP mode
+    }
+
+    gb->debugger_ticks += cycles;
+
+    if (!gb->cgb_double_speed) {
+        cycles <<= 1;
+    }
+    
+    // Not affected by speed boost
+    gb->double_speed_alignment += cycles;
+    gb->hdma_cycles += cycles;
+    gb->apu_output.sample_cycles += cycles;
+    gb->cycles_since_ir_change += cycles;
+    gb->cycles_since_input_ir_change += cycles;
+    gb->cycles_since_last_sync += cycles;
+    gb->cycles_since_run += cycles;
+    if (!gb->stopped) { // TODO: Verify what happens in STOP mode
+        GB_dma_run(gb);
+        GB_hdma_run(gb);
+    }
+    GB_apu_run(gb);
+    GB_display_run(gb, cycles);
+    GB_ir_run(gb);
+}
+
+/* 
+   This glitch is based on the expected results of mooneye-gb rapid_toggle test.
+   This glitch happens because how TIMA is increased, see GB_set_internal_div_counter.
+   According to GiiBiiAdvance, GBC's behavior is different, but this was not tested or implemented.
+*/
+void GB_emulate_timer_glitch(GB_gameboy_t *gb, uint8_t old_tac, uint8_t new_tac)
+{
+    /* Glitch only happens when old_tac is enabled. */
+    if (!(old_tac & 4)) return;
+
+    unsigned old_clocks = GB_TAC_TRIGGER_BITS[old_tac & 3];
+    unsigned new_clocks = GB_TAC_TRIGGER_BITS[new_tac & 3];
+
+    /* The bit used for overflow testing must have been 1 */
+    if (gb->div_counter & old_clocks) {
+        /* And now either the timer must be disabled, or the new bit used for overflow testing be 0. */
+        if (!(new_tac & 4) || gb->div_counter & new_clocks) {
+            increase_tima(gb);
+        }
+    }
+}
+
+void GB_rtc_run(GB_gameboy_t *gb)
+{
+    if ((gb->rtc_real.high & 0x40) == 0) { /* is timer running? */
+        time_t current_time = time(NULL);
+        while (gb->last_rtc_second < current_time) {
+            gb->last_rtc_second++;
+            if (++gb->rtc_real.seconds == 60)
+            {
+                gb->rtc_real.seconds = 0;
+                if (++gb->rtc_real.minutes == 60)
+                {
+                    gb->rtc_real.minutes = 0;
+                    if (++gb->rtc_real.hours == 24)
+                    {
+                        gb->rtc_real.hours = 0;
+                        if (++gb->rtc_real.days == 0)
+                        {
+                            if (gb->rtc_real.high & 1) /* Bit 8 of days*/
+                            {
+                                gb->rtc_real.high |= 0x80; /* Overflow bit */
+                            }
+                            gb->rtc_real.high ^= 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

bsnes/gb/Core/timing.h

@@ -0,0 +1,44 @@
+#ifndef timing_h
+#define timing_h
+#include "gb_struct_def.h"
+
+#ifdef GB_INTERNAL
+void GB_advance_cycles(GB_gameboy_t *gb, uint8_t cycles);
+void GB_rtc_run(GB_gameboy_t *gb);
+void GB_emulate_timer_glitch(GB_gameboy_t *gb, uint8_t old_tac, uint8_t new_tac);
+bool GB_timing_sync_turbo(GB_gameboy_t *gb); /* Returns true if should skip frame */
+void GB_timing_sync(GB_gameboy_t *gb);
+
+enum {
+    GB_TIMA_RUNNING = 0,
+    GB_TIMA_RELOADING = 1,
+    GB_TIMA_RELOADED = 2
+};
+
+#define GB_HALT_VALUE (0xFFFF)
+
+#define GB_SLEEP(gb, unit, state, cycles) do {\
+    (gb)->unit##_cycles -= (cycles) * __state_machine_divisor; \
+    if ((gb)->unit##_cycles <= 0) {\
+        (gb)->unit##_state = state;\
+        return;\
+        unit##state:; \
+    }\
+} while (0)
+
+#define GB_HALT(gb, unit) (gb)->unit##_cycles = GB_HALT_VALUE
+
+#define GB_STATE_MACHINE(gb, unit, cycles, divisor) \
+static const int __state_machine_divisor = divisor;\
+(gb)->unit##_cycles += cycles; \
+if ((gb)->unit##_cycles <= 0 || (gb)->unit##_cycles == GB_HALT_VALUE) {\
+    return;\
+}\
+switch ((gb)->unit##_state)
+#endif
+
+#define GB_STATE(gb, unit, state) case state: goto unit##state
+
+#define GB_UNIT(unit) int32_t unit##_cycles, unit##_state
+
+#endif /* timing_h */

bsnes/gb/GNUmakefile

@@ -0,0 +1,25 @@
+flags += -DGB_INTERNAL -DDISABLE_DEBUGGER -D_GNU_SOURCE -Wno-multichar
+options += -I../sameboy
+
+objects += gb-apu gb-camera gb-display gb-gb gb-joypad gb-mbc
+objects += gb-memory gb-printer gb-random gb-rewind gb-save_state gb-sgb
+objects += gb-sm83_cpu gb-symbol_hash gb-timing
+#objects+= gb-debugger gb-sm83_disassembler
+
+obj/gb-apu.o:               gb/Core/apu.c
+obj/gb-camera.o:            gb/Core/camera.c
+obj/gb-debugger.o:          gb/Core/debugger.c
+obj/gb-display.o:           gb/Core/display.c
+obj/gb-gb.o:                gb/Core/gb.c
+obj/gb-joypad.o:            gb/Core/joypad.c
+obj/gb-mbc.o:               gb/Core/mbc.c
+obj/gb-memory.o:            gb/Core/memory.c
+obj/gb-printer.o:           gb/Core/printer.c
+obj/gb-random.o:            gb/Core/random.c
+obj/gb-rewind.o:            gb/Core/rewind.c
+obj/gb-save_state.o:        gb/Core/save_state.c
+obj/gb-sgb.o:               gb/Core/sgb.c
+obj/gb-sm83_cpu.o:          gb/Core/sm83_cpu.c
+obj/gb-sm83_disassembler.o: gb/Core/sm83_disassembler.c
+obj/gb-symbol_hash.o:       gb/Core/symbol_hash.c
+obj/gb-timing.o:            gb/Core/timing.c

bsnes/gb/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015-2019 Lior Halphon
+
+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.

bsnes/heuristics/bs-memory.cpp

@@ -0,0 +1,33 @@
+namespace Heuristics {
+
+struct BSMemory {
+  BSMemory(vector<uint8_t>& data, string location);
+  explicit operator bool() const;
+  auto manifest() const -> string;
+
+private:
+  vector<uint8_t>& data;
+  string location;
+};
+
+BSMemory::BSMemory(vector<uint8_t>& data, string location) : data(data), location(location) {
+}
+
+BSMemory::operator bool() const {
+  return data.size() >= 0x8000;
+}
+
+auto BSMemory::manifest() const -> string {
+  if(!operator bool()) return {};
+
+  string output;
+  output.append("game\n");
+  output.append("  sha256: ", Hash::SHA256(data).digest(), "\n");
+  output.append("  label:  ", Location::prefix(location), "\n");
+  output.append("  name:   ", Location::prefix(location), "\n");
+  output.append("  board\n");
+  output.append(Memory{}.type("Flash").size(data.size()).content("Program").text());
+  return output;
+}
+
+}

bsnes/heuristics/game-boy.cpp

@@ -0,0 +1,298 @@
+namespace Heuristics {
+
+struct GameBoy {
+  GameBoy(vector<uint8_t>& data, string location);
+  explicit operator bool() const;
+  auto manifest() const -> string;
+
+private:
+  auto read(uint offset) const -> uint8_t { return data[headerAddress + offset]; }
+
+  vector<uint8_t>& data;
+  string location;
+  uint headerAddress = 0;
+};
+
+GameBoy::GameBoy(vector<uint8_t>& data, string location) : data(data), location(location) {
+  headerAddress = data.size() < 0x8000 ? data.size() : data.size() - 0x8000;
+  if(read(0x0104) == 0xce && read(0x0105) == 0xed && read(0x0106) == 0x66 && read(0x0107) == 0x66
+  && read(0x0108) == 0xcc && read(0x0109) == 0x0d && read(0x0147) >= 0x0b && read(0x0147) <= 0x0d
+  ) {  //MMM01 stores header at bottom of data[]
+  } else { //all other mappers store header at top of data[]
+    headerAddress = 0;
+  }
+}
+
+GameBoy::operator bool() const {
+  return data.size() >= 0x4000;
+}
+
+auto GameBoy::manifest() const -> string {
+  if(!operator bool()) return {};
+
+  bool black = (read(0x0143) & 0xc0) == 0x80;  //cartridge works in DMG+CGB mode
+  bool clear = (read(0x0143) & 0xc0) == 0xc0;  //cartridge works in CGB mode only
+
+  bool ram = false;
+  bool battery = false;
+  bool eeprom = false;
+  bool flash = false;
+  bool rtc = false;
+  bool accelerometer = false;
+  bool rumble = false;
+
+  uint romSize = 0;
+  uint ramSize = 0;
+  uint eepromSize = 0;
+  uint flashSize = 0;
+  uint rtcSize = 0;
+
+  string mapper = "MBC0";
+
+  switch(read(0x0147)) {
+
+  case 0x00:
+    mapper = "MBC0";
+    break;
+
+  case 0x01:
+    mapper = "MBC1";
+    break;
+
+  case 0x02:
+    mapper = "MBC1";
+    ram = true;
+    break;
+
+  case 0x03:
+    mapper = "MBC1";
+    battery = true;
+    ram = true;
+    break;
+
+  case 0x05:
+    mapper = "MBC2";
+    ram = true;
+    break;
+
+  case 0x06:
+    mapper = "MBC2";
+    battery = true;
+    ram = true;
+    break;
+
+  case 0x08:
+    mapper = "MBC0";
+    ram = true;
+    break;
+
+  case 0x09:
+    mapper = "MBC0";
+    battery = true;
+    ram = true;
+    break;
+
+  case 0x0b:
+    mapper = "MMM01";
+    break;
+
+  case 0x0c:
+    mapper = "MMM01";
+    ram = true;
+    break;
+
+  case 0x0d:
+    mapper = "MMM01";
+    battery = true;
+    ram = true;
+    break;
+
+  case 0x0f:
+    mapper = "MBC3";
+    battery = true;
+    rtc = true;
+    break;
+
+  case 0x10:
+    mapper = "MBC3";
+    battery = true;
+    ram = true;
+    rtc = true;
+    break;
+
+  case 0x11:
+    mapper = "MBC3";
+    break;
+
+  case 0x12:
+    mapper = "MBC3";
+    ram = true;
+    break;
+
+  case 0x13:
+    mapper = "MBC3";
+    battery = true;
+    ram = true;
+    break;
+
+  case 0x19:
+    mapper = "MBC5";
+    break;
+
+  case 0x1a:
+    mapper = "MBC5";
+    ram = true;
+    break;
+
+  case 0x1b:
+    mapper = "MBC5";
+    battery = true;
+    ram = true;
+    break;
+
+  case 0x1c:
+    mapper = "MBC5";
+    rumble = true;
+    break;
+
+  case 0x1d:
+    mapper = "MBC5";
+    ram = true;
+    rumble = true;
+    break;
+
+  case 0x1e:
+    mapper = "MBC5";
+    battery = true;
+    ram = true;
+    rumble = true;
+    break;
+
+  case 0x20:
+    mapper = "MBC6";
+    flash = true;
+    battery = true;
+    ram = true;
+    break;
+
+  case 0x22:
+    mapper = "MBC7";
+    battery = true;
+    eeprom = true;
+    accelerometer = true;
+    rumble = true;
+    break;
+
+  case 0xfc:
+    mapper = "CAMERA";
+    break;
+
+  case 0xfd:
+    mapper = "TAMA";
+    battery = true;
+    ram = true;
+    rtc = true;
+    break;
+
+  case 0xfe:
+    mapper = "HuC3";
+    break;
+
+  case 0xff:
+    mapper = "HuC1";
+    battery = true;
+    ram = true;
+    break;
+
+  }
+
+  //Game Boy: title = $0134-0143
+  //Game Boy Color (early games): title = $0134-0142; model = $0143
+  //Game Boy Color (later games): title = $0134-013e; serial = $013f-0142; model = $0143
+  string title;
+  for(uint n : range(black || clear ? 15 : 16)) {
+    char byte = read(0x0134 + n);
+    if(byte < 0x20 || byte > 0x7e) byte = ' ';
+    title.append(byte);
+  }
+
+  string serial = title.slice(-4);
+  if(!black && !clear) serial = "";
+  for(auto& byte : serial) {
+    if(byte >= 'A' && byte <= 'Z') continue;
+    //invalid serial
+    serial = "";
+    break;
+  }
+  title.trimRight(serial, 1L);  //remove the serial from the title, if it exists
+  title.strip();  //remove any excess whitespace from the title
+
+  switch(read(0x0148)) { default:
+  case 0x00: romSize =   2 * 16 * 1024; break;
+  case 0x01: romSize =   4 * 16 * 1024; break;
+  case 0x02: romSize =   8 * 16 * 1024; break;
+  case 0x03: romSize =  16 * 16 * 1024; break;
+  case 0x04: romSize =  32 * 16 * 1024; break;
+  case 0x05: romSize =  64 * 16 * 1024; break;
+  case 0x06: romSize = 128 * 16 * 1024; break;
+  case 0x07: romSize = 256 * 16 * 1024; break;
+  case 0x52: romSize =  72 * 16 * 1024; break;
+  case 0x53: romSize =  80 * 16 * 1024; break;
+  case 0x54: romSize =  96 * 16 * 1024; break;
+  }
+
+  switch(read(0x0149)) { default:
+  case 0x00: ramSize =  0 * 1024; break;
+  case 0x01: ramSize =  2 * 1024; break;
+  case 0x02: ramSize =  8 * 1024; break;
+  case 0x03: ramSize = 32 * 1024; break;
+  }
+
+  if(mapper == "MBC2" && ram) ramSize = 256;
+  if(mapper == "MBC6" && ram) ramSize =  32 * 1024;
+  if(mapper == "TAMA" && ram) ramSize =  32;
+
+  if(mapper == "MBC6" && flash) flashSize = 1024 * 1024;
+
+  //Game Boy header does not specify EEPROM size: detect via game title instead
+  //Command Master:        EEPROM = 512 bytes
+  //Kirby Tilt 'n' Tumble: EEPROM = 256 bytes
+  //Korokoro Kirby:        EEPROM = 256 bytes
+  if(mapper == "MBC7" && eeprom) {
+    eepromSize = 256;  //fallback guess; supported values are 128, 256, 512
+    if(title == "CMASTER"     && serial == "KCEJ") eepromSize = 512;
+    if(title == "KIRBY TNT"   && serial == "KTNE") eepromSize = 256;
+    if(title == "KORO2 KIRBY" && serial == "KKKJ") eepromSize = 256;
+  }
+
+  if(mapper == "MBC3" && rtc) rtcSize = 13;
+  if(mapper == "TAMA" && rtc) rtcSize = 21;
+
+  string output;
+  output.append("game\n");
+  output.append("  sha256: ", Hash::SHA256(data).digest(), "\n");
+  output.append("  label:  ", Location::prefix(location), "\n");
+  output.append("  name:   ", Location::prefix(location), "\n");
+  output.append("  title:  ", title, "\n");
+if(serial)
+  output.append("  serial: ", serial, "\n");
+  output.append("  board:  ", mapper, "\n");
+  output.append(Memory{}.type("ROM").size(data.size()).content("Program").text());
+if(ram && ramSize && battery)
+  output.append(Memory{}.type("RAM").size(ramSize).content("Save").text());
+if(ram && ramSize && !battery)
+  output.append(Memory{}.type("RAM").size(ramSize).content("Save").isVolatile().text());
+if(eeprom && eepromSize)
+  output.append(Memory{}.type("EEPROM").size(eepromSize).content("Save").text());
+if(flash && flashSize)
+  output.append(Memory{}.type("Flash").size(flashSize).content("Download").text());
+if(rtc && rtcSize)
+  output.append(Memory{}.type("RTC").size(rtcSize).content("Time").text());
+if(accelerometer)
+  output.append("    accelerometer\n");
+if(rumble)
+  output.append("    rumble\n");
+  return output;
+}
+
+}

bsnes/heuristics/heuristics.cpp

@@ -0,0 +1,34 @@
+namespace Heuristics {
+
+auto Memory::text() const -> string {
+  string output;
+  output.append("    memory\n");
+  output.append("      type: ", _type, "\n");
+  output.append("      size: 0x", hex(_size), "\n");
+  output.append("      content: ", _content, "\n");
+if(_manufacturer)
+  output.append("      manufacturer: ", _manufacturer, "\n");
+if(_architecture)
+  output.append("      architecture: ", _architecture, "\n");
+if(_identifier)
+  output.append("      identifier: ", _identifier, "\n");
+if(_volatile)
+  output.append("      volatile\n");
+  return output;
+}
+
+auto Oscillator::text() const -> string {
+  string output;
+  output.append("    oscillator\n");
+  output.append("      frequency: ", _frequency, "\n");
+  return output;
+}
+
+auto Slot::text() const -> string {
+  string output;
+  output.append("    slot\n");
+  output.append("      type: ", _type, "\n");
+  return output;
+}
+
+}

bsnes/heuristics/heuristics.hpp

@@ -0,0 +1,37 @@
+namespace Heuristics {
+
+struct Memory {
+  auto& type(string type) { _type = type; return *this; }
+  auto& size(natural size) { _size = size; return *this; }
+  auto& content(string content) { _content = content; return *this; }
+  auto& manufacturer(string manufacturer) { _manufacturer = manufacturer; return *this; }
+  auto& architecture(string architecture) { _architecture = architecture; return *this; }
+  auto& identifier(string identifier) { _identifier = identifier; return *this; }
+  auto& isVolatile() { _volatile = true; return *this; }
+  auto text() const -> string;
+
+  string _type;
+  boolean _battery;
+  natural _size;
+  string _content;
+  string _manufacturer;
+  string _architecture;
+  string _identifier;
+  boolean _volatile;
+};
+
+struct Oscillator {
+  auto& frequency(natural frequency) { _frequency = frequency; return *this; }
+  auto text() const -> string;
+
+  natural _frequency;
+};
+
+struct Slot {
+  auto& type(string type) { _type = type; return *this; }
+  auto text() const -> string;
+
+  string _type;
+};
+
+}

bsnes/heuristics/sufami-turbo.cpp

@@ -0,0 +1,39 @@
+namespace Heuristics {
+
+struct SufamiTurbo {
+  SufamiTurbo(vector<uint8_t>& data, string location);
+  explicit operator bool() const;
+
+  auto manifest() const -> string;
+
+private:
+  vector<uint8_t>& data;
+  string location;
+};
+
+SufamiTurbo::SufamiTurbo(vector<uint8_t>& data, string location) : data(data), location(location) {
+}
+
+SufamiTurbo::operator bool() const {
+  return data.size() >= 0x20000;
+}
+
+auto SufamiTurbo::manifest() const -> string {
+  if(!operator bool()) return {};
+
+  uint romSize = data[0x36] * 0x20000;  //128KB
+  uint ramSize = data[0x37] *   0x800;  //  2KB
+
+  string output;
+  output.append("game\n");
+  output.append("  sha256: ", Hash::SHA256(data).digest(), "\n");
+  output.append("  label:  ", Location::prefix(location), "\n");
+  output.append("  name:   ", Location::prefix(location), "\n");
+  output.append("  board\n");
+  output.append(Memory{}.type("ROM").size(data.size()).content("Program").text());
+if(ramSize)
+  output.append(Memory{}.type("RAM").size(ramSize).content("Save").text());
+  return output;
+}
+
+}

bsnes/heuristics/super-famicom.cpp

@@ -0,0 +1,569 @@
+namespace Heuristics {
+
+struct SuperFamicom {
+  SuperFamicom(vector<uint8_t>& data, string location);
+  explicit operator bool() const;
+
+  auto manifest() const -> string;
+  auto region() const -> string;
+  auto videoRegion() const -> string;
+  auto revision() const -> string;
+  auto board() const -> string;
+  auto title() const -> string;
+  auto serial() const -> string;
+  auto romSize() const -> uint;
+  auto programRomSize() const -> uint;
+  auto dataRomSize() const -> uint;
+  auto expansionRomSize() const -> uint;
+  auto firmwareRomSize() const -> uint;
+  auto ramSize() const -> uint;
+  auto expansionRamSize() const -> uint;
+  auto nonVolatile() const -> bool;
+
+private:
+  auto size() const -> uint { return data.size(); }
+  auto scoreHeader(uint address) -> uint;
+  auto firmwareARM() const -> string;
+  auto firmwareEXNEC() const -> string;
+  auto firmwareGB() const -> string;
+  auto firmwareHITACHI() const -> string;
+  auto firmwareNEC() const -> string;
+
+  vector<uint8_t>& data;
+  string location;
+  uint headerAddress = 0;
+};
+
+SuperFamicom::SuperFamicom(vector<uint8_t>& data, string location) : data(data), location(location) {
+  if((size() & 0x7fff) == 512) {
+    //remove header if present
+    memory::move(&data[0], &data[512], size() - 512);
+    data.resize(size() - 512);
+  }
+
+  if(size() < 0x8000) return;  //ignore images too small to be valid
+
+  uint LoROM   = scoreHeader(  0x7fb0);
+  uint HiROM   = scoreHeader(  0xffb0);
+  uint ExLoROM = scoreHeader(0x407fb0);
+  uint ExHiROM = scoreHeader(0x40ffb0);
+  if(ExLoROM) ExLoROM += 4;
+  if(ExHiROM) ExHiROM += 4;
+
+  if(LoROM >= HiROM && LoROM >= ExLoROM && LoROM >= ExHiROM) headerAddress = 0x7fb0;
+  else if(HiROM >= ExLoROM && HiROM >= ExHiROM) headerAddress = 0xffb0;
+  else if(ExLoROM >= ExHiROM) headerAddress = 0x407fb0;
+  else headerAddress = 0x40ffb0;
+}
+
+SuperFamicom::operator bool() const {
+  return headerAddress;
+}
+
+auto SuperFamicom::manifest() const -> string {
+  if(!operator bool()) return {};
+
+  string output;
+  output.append("game\n");
+  output.append("  sha256:   ", Hash::SHA256(data).digest(), "\n");
+  output.append("  label:    ", Location::prefix(location), "\n");
+  output.append("  name:     ", Location::prefix(location), "\n");
+  output.append("  title:    ", title(), "\n");
+  output.append("  region:   ", region(), "\n");
+  output.append("  revision: ", revision(), "\n");
+  output.append("  board:    ", board(), "\n");
+
+  auto board = this->board().trimRight("#A", 1L).split("-");
+
+  if(auto size = romSize()) {
+    if(board(0) == "SPC7110" && size > 0x100000) {
+      output.append(Memory{}.type("ROM").size(0x100000).content("Program").text());
+      output.append(Memory{}.type("ROM").size(size - 0x100000).content("Data").text());
+    } else if(board(0) == "EXSPC7110" && size == 0x700000) {
+      //Tengai Maykou Zero (fan translation)
+      output.append(Memory{}.type("ROM").size(0x100000).content("Program").text());
+      output.append(Memory{}.type("ROM").size(0x500000).content("Data").text());
+      output.append(Memory{}.type("ROM").size(0x100000).content("Expansion").text());
+    } else {
+      output.append(Memory{}.type("ROM").size(size).content("Program").text());
+    }
+  }
+
+  if(auto size = ramSize()) {
+    output.append(Memory{}.type("RAM").size(size).content("Save").text());
+  }
+
+  if(auto size = expansionRamSize()) {
+    output.append(Memory{}.type("RAM").size(size).content("Save").text());
+  }
+
+  if(0) {
+  } else if(board(0) == "ARM") {
+    output.append(Memory{}.type("ROM").size(0x20000).content("Program").manufacturer("SETA").architecture("ARM6").identifier(firmwareARM()).text());
+    output.append(Memory{}.type("ROM").size( 0x8000).content("Data"   ).manufacturer("SETA").architecture("ARM6").identifier(firmwareARM()).text());
+    output.append(Memory{}.type("RAM").size( 0x4000).content("Data"   ).manufacturer("SETA").architecture("ARM6").identifier(firmwareARM()).isVolatile().text());
+    output.append(Oscillator{}.frequency(21'440'000).text());
+  } else if(board(0) == "BS" && board(1) == "MCC") {
+    output.append(Memory{}.type("RAM").size(0x80000).content("Download").text());
+  } else if(board(0) == "EXNEC") {
+    output.append(Memory{}.type("ROM").size(0xc000).content("Program").manufacturer("NEC").architecture("uPD96050").identifier(firmwareEXNEC()).text());
+    output.append(Memory{}.type("ROM").size(0x1000).content("Data"   ).manufacturer("NEC").architecture("uPD96050").identifier(firmwareEXNEC()).text());
+    output.append(Memory{}.type("RAM").size(0x1000).content("Data"   ).manufacturer("NEC").architecture("uPD96050").identifier(firmwareEXNEC()).text());
+    output.append(Oscillator{}.frequency(firmwareEXNEC() == "ST010" ? 11'000'000 : 15'000'000).text());
+  } else if(board(0) == "GB") {
+    output.append(Memory{}.type("ROM").size(0x100).content("Boot").manufacturer("Nintendo").architecture("LR35902").identifier(firmwareGB()).text());
+  if(firmwareGB() == "SGB2")
+    output.append(Oscillator{}.frequency(20'971'520).text());
+  } else if(board(0) == "GSU") {
+  //todo: MARIO CHIP 1 uses CPU oscillator
+    output.append(Oscillator{}.frequency(21'440'000).text());
+  } else if(board(0) == "HITACHI") {
+    output.append(Memory{}.type("ROM").size(0xc00).content("Data").manufacturer("Hitachi").architecture("HG51BS169").identifier(firmwareHITACHI()).text());
+    output.append(Memory{}.type("RAM").size(0xc00).content("Data").manufacturer("Hitachi").architecture("HG51BS169").identifier(firmwareHITACHI()).isVolatile().text());
+    output.append(Oscillator{}.frequency(20'000'000).text());
+  } else if(board(0) == "NEC") {
+    output.append(Memory{}.type("ROM").size(0x1800).content("Program").manufacturer("NEC").architecture("uPD7725").identifier(firmwareNEC()).text());
+    output.append(Memory{}.type("ROM").size( 0x800).content("Data"   ).manufacturer("NEC").architecture("uPD7725").identifier(firmwareNEC()).text());
+    output.append(Memory{}.type("RAM").size( 0x200).content("Data"   ).manufacturer("NEC").architecture("uPD7725").identifier(firmwareNEC()).isVolatile().text());
+    output.append(Oscillator{}.frequency(7'600'000).text());
+  } else if(board(0) == "SA1" || board(1) == "SA1") {  //SA1-* or BS-SA1-*
+    output.append(Memory{}.type("RAM").size(0x800).content("Internal").isVolatile().text());
+  }
+
+  if(board.right() == "EPSONRTC") {
+    output.append(Memory{}.type("RTC").size(0x10).content("Time").manufacturer("Epson").text());
+  } else if(board.right() == "SHARPRTC") {
+    output.append(Memory{}.type("RTC").size(0x10).content("Time").manufacturer("Sharp").text());
+  }
+
+  return output;
+}
+
+auto SuperFamicom::region() const -> string {
+  //Unlicensed software (homebrew, ROM hacks, etc) often change the standard region code,
+  //and then neglect to change the extended header region code. Thanks to that, we can't
+  //decode and display the full game serial + region code.
+  return videoRegion();
+
+  string region;
+
+  char A = data[headerAddress + 0x02];  //game type
+  char B = data[headerAddress + 0x03];  //game code
+  char C = data[headerAddress + 0x04];  //game code
+  char D = data[headerAddress + 0x05];  //region code (new; sometimes ambiguous)
+  auto E = data[headerAddress + 0x29];  //region code (old)
+
+  auto valid = [](char n) { return (n >= '0' && n <= '9') || (n >= 'A' && n <= 'Z'); };
+  if(data[headerAddress + 0x2a] == 0x33 && valid(A) && valid(B) & valid(C) & valid(D)) {
+    string code{A, B, C, D};
+    if(D == 'B') region = {"SNS-",  code, "-BRA"};
+    if(D == 'C') region = {"SNSN-", code, "-ROC"};
+    if(D == 'D') region = {"SNSP-", code, "-NOE"};
+    if(D == 'E') region = {"SNS-",  code, "-USA"};
+    if(D == 'F') region = {"SNSP-", code, "-FRA"};
+    if(D == 'H') region = {"SNSP-", code, "-HOL"};
+    if(D == 'I') region = {"SNSP-", code, "-ITA"};
+    if(D == 'J') region = {"SHVC-", code, "-JPN"};
+    if(D == 'K') region = {"SNSN-", code, "-KOR"};
+    if(D == 'N') region = {"SNS-",  code, "-CAN"};
+    if(D == 'P') region = {"SNSP-", code, "-EUR"};
+    if(D == 'S') region = {"SNSP-", code, "-ESP"};
+    if(D == 'U') region = {"SNSP-", code, "-AUS"};
+    if(D == 'W') region = {"SNSP-", code, "-SCN"};
+  }
+
+  if(!region) {
+    if(E == 0x00) region = {"JPN"};
+    if(E == 0x01) region = {"USA"};
+    if(E == 0x02) region = {"EUR"};
+    if(E == 0x03) region = {"SCN"};
+    if(E == 0x06) region = {"FRA"};
+    if(E == 0x07) region = {"HOL"};
+    if(E == 0x08) region = {"ESP"};
+    if(E == 0x09) region = {"NOE"};
+    if(E == 0x0a) region = {"ITA"};
+    if(E == 0x0b) region = {"ROC"};
+    if(E == 0x0d) region = {"KOR"};
+    if(E == 0x0f) region = {"CAN"};
+    if(E == 0x10) region = {"BRA"};
+    if(E == 0x11) region = {"AUS"};
+  }
+
+  return region ? region : "NTSC";
+}
+
+auto SuperFamicom::videoRegion() const -> string {
+  auto region = data[headerAddress + 0x29];
+  return (region <= 0x01 || region >= 0x12) ? "NTSC" : "PAL";
+}
+
+auto SuperFamicom::revision() const -> string {
+  string revision;
+
+  char A = data[headerAddress + 0x02];  //game type
+  char B = data[headerAddress + 0x03];  //game code
+  char C = data[headerAddress + 0x04];  //game code
+  char D = data[headerAddress + 0x05];  //region code (new; sometimes ambiguous)
+  auto E = data[headerAddress + 0x29];  //region code (old)
+  uint F = data[headerAddress + 0x2b];  //revision code
+
+  auto valid = [](char n) { return (n >= '0' && n <= '9') || (n >= 'A' && n <= 'Z'); };
+  if(data[headerAddress + 0x2a] == 0x33 && valid(A) && valid(B) & valid(C) & valid(D)) {
+    string code{A, B, C, D};
+    if(D == 'B') revision = {"SNS-",  code, "-", F};
+    if(D == 'C') revision = {"SNSN-", code, "-", F};
+    if(D == 'D') revision = {"SNSP-", code, "-", F};
+    if(D == 'E') revision = {"SNS-",  code, "-", F};
+    if(D == 'F') revision = {"SNSP-", code, "-", F};
+    if(D == 'H') revision = {"SNSP-", code, "-", F};
+    if(D == 'I') revision = {"SNSP-", code, "-", F};
+    if(D == 'J') revision = {"SHVC-", code, "-", F};
+    if(D == 'K') revision = {"SNSN-", code, "-", F};
+    if(D == 'N') revision = {"SNS-",  code, "-", F};
+    if(D == 'P') revision = {"SNSP-", code, "-", F};
+    if(D == 'S') revision = {"SNSP-", code, "-", F};
+    if(D == 'U') revision = {"SNSP-", code, "-", F};
+    if(D == 'W') revision = {"SNSP-", code, "-", F};
+  }
+
+  if(!revision) {
+    revision = {"1.", F};
+  }
+
+  return revision ? revision : string{"1.", F};
+}
+
+//format: [slot]-[coprocessor]-[mapper]-[ram]-[rtc]
+auto SuperFamicom::board() const -> string {
+  string board;
+
+  auto mapMode          = data[headerAddress + 0x25];
+  auto cartridgeTypeLo  = data[headerAddress + 0x26] & 15;
+  auto cartridgeTypeHi  = data[headerAddress + 0x26] >> 4;
+  auto cartridgeSubType = data[headerAddress + 0x0f];
+
+  string mode;
+  if(mapMode == 0x20 || mapMode == 0x30) mode = "LOROM-";
+  if(mapMode == 0x21 || mapMode == 0x31) mode = "HIROM-";
+  if(mapMode == 0x22 || mapMode == 0x32) mode = "SDD1-";
+  if(mapMode == 0x23 || mapMode == 0x33) mode = "SA1-";
+  if(mapMode == 0x25 || mapMode == 0x35) mode = "EXHIROM-";
+  if(mapMode == 0x2a || mapMode == 0x3a) mode = "SPC7110-";
+
+  //many games will store an extra title character, overwriting the map mode
+  //further, ExLoROM mode is unofficial, and lacks a mapping mode value
+  if(!mode) {
+    if(headerAddress ==   0x7fb0) mode = "LOROM-";
+    if(headerAddress ==   0xffb0) mode = "HIROM-";
+    if(headerAddress == 0x407fb0) mode = "EXLOROM-";
+    if(headerAddress == 0x40ffb0) mode = "EXHIROM-";
+  }
+
+  if(mode == "LOROM-" && headerAddress == 0x407fb0) mode = "EXLOROM-";
+
+  bool epsonRTC = false;
+  bool sharpRTC = false;
+
+         if(serial() == "A9PJ") {
+  //Sufami Turbo (JPN)
+    board.append("ST-", mode);
+  } else if(serial() == "ZBSJ") {
+  //BS-X: Sore wa Namae o Nusumareta Machi no Monogatari (JPN)
+    board.append("BS-MCC-");
+  } else if(serial() == "042J") {
+  //Super Game Boy 2
+    board.append("GB-", mode);
+  } else if(serial().match("Z??J")) {
+    board.append("BS-", mode);
+  } else if(cartridgeTypeLo >= 0x3) {
+    if(cartridgeTypeHi == 0x0) board.append("NEC-", mode);
+    if(cartridgeTypeHi == 0x1) board.append("GSU-");
+    if(cartridgeTypeHi == 0x2) board.append("OBC1-", mode);
+    if(cartridgeTypeHi == 0x3) board.append("SA1-");
+    if(cartridgeTypeHi == 0x4) board.append("SDD1-");
+    if(cartridgeTypeHi == 0x5) board.append(mode), sharpRTC = true;
+    if(cartridgeTypeHi == 0xe && cartridgeTypeLo == 0x3) board.append("GB-", mode);
+    if(cartridgeTypeHi == 0xf && cartridgeTypeLo == 0x5 && cartridgeSubType == 0x00) board.append("SPC7110-");
+    if(cartridgeTypeHi == 0xf && cartridgeTypeLo == 0x9 && cartridgeSubType == 0x00) board.append("SPC7110-"), epsonRTC = true;
+    if(cartridgeTypeHi == 0xf                           && cartridgeSubType == 0x01) board.append("EXNEC-", mode);
+    if(cartridgeTypeHi == 0xf                           && cartridgeSubType == 0x02) board.append("ARM-", mode);
+    if(cartridgeTypeHi == 0xf                           && cartridgeSubType == 0x10) board.append("HITACHI-", mode);
+  }
+  if(!board) board.append(mode);
+
+  if(ramSize() || expansionRamSize()) board.append("RAM-");
+  if(epsonRTC) board.append("EPSONRTC-");
+  if(sharpRTC) board.append("SHARPRTC-");
+
+  board.trimRight("-", 1L);
+
+  if(board.beginsWith(    "LOROM-RAM") && romSize() <= 0x200000) board.append("#A");
+  if(board.beginsWith("NEC-LOROM-RAM") && romSize() <= 0x100000) board.append("#A");
+
+  //Tengai Makyou Zero (fan translation)
+  if(board.beginsWith("SPC7110-") && data.size() == 0x700000) board.prepend("EX");
+
+  return board;
+}
+
+auto SuperFamicom::title() const -> string {
+  string label;
+
+  for(uint n = 0; n < 0x15; n++) {
+    auto x = data[headerAddress + 0x10 + n];
+    auto y = n == 0x14 ? 0 : data[headerAddress + 0x11 + n];
+
+    //null terminator (padding)
+    if(x == 0x00 || x == 0xff);
+
+    //ASCII
+    else if(x >= 0x20 && x <= 0x7e) label.append((char)x);
+
+    //Shift-JIS (half-width katakana)
+    else if(x == 0xa1) label.append("。");
+    else if(x == 0xa2) label.append("「");
+    else if(x == 0xa3) label.append("」");
+    else if(x == 0xa4) label.append("、");
+    else if(x == 0xa5) label.append("・");
+    else if(x == 0xa6) label.append("ヲ");
+    else if(x == 0xa7) label.append("ァ");
+    else if(x == 0xa8) label.append("ィ");
+    else if(x == 0xa9) label.append("ゥ");
+    else if(x == 0xaa) label.append("ェ");
+    else if(x == 0xab) label.append("ォ");
+    else if(x == 0xac) label.append("ャ");
+    else if(x == 0xad) label.append("ュ");
+    else if(x == 0xae) label.append("ョ");
+    else if(x == 0xaf) label.append("ッ");
+    else if(x == 0xb0) label.append("ー");
+
+    else if(x == 0xb1) label.append(                 "ア");
+    else if(x == 0xb2) label.append(                 "イ");
+    else if(x == 0xb3) label.append(y == 0xde ? "ヴ" : "ウ");
+    else if(x == 0xb4) label.append(                 "エ");
+    else if(x == 0xb5) label.append(                 "オ");
+
+    else if(x == 0xb6) label.append(y == 0xde ? "ガ" : "カ");
+    else if(x == 0xb7) label.append(y == 0xde ? "ギ" : "キ");
+    else if(x == 0xb8) label.append(y == 0xde ? "グ" : "ク");
+    else if(x == 0xb9) label.append(y == 0xde ? "ゲ" : "ケ");
+    else if(x == 0xba) label.append(y == 0xde ? "ゴ" : "コ");
+
+    else if(x == 0xbb) label.append(y == 0xde ? "ザ" : "サ");
+    else if(x == 0xbc) label.append(y == 0xde ? "ジ" : "シ");
+    else if(x == 0xbd) label.append(y == 0xde ? "ズ" : "ス");
+    else if(x == 0xbe) label.append(y == 0xde ? "ゼ" : "セ");
+    else if(x == 0xbf) label.append(y == 0xde ? "ゾ" : "ソ");
+
+    else if(x == 0xc0) label.append(y == 0xde ? "ダ" : "タ");
+    else if(x == 0xc1) label.append(y == 0xde ? "ヂ" : "チ");
+    else if(x == 0xc2) label.append(y == 0xde ? "ヅ" : "ツ");
+    else if(x == 0xc3) label.append(y == 0xde ? "デ" : "テ");
+    else if(x == 0xc4) label.append(y == 0xde ? "ド" : "ト");
+
+    else if(x == 0xc5) label.append("ナ");
+    else if(x == 0xc6) label.append("ニ");
+    else if(x == 0xc7) label.append("ヌ");
+    else if(x == 0xc8) label.append("ネ");
+    else if(x == 0xc9) label.append("ノ");
+
+    else if(x == 0xca) label.append(y == 0xdf ? "パ" : y == 0xde ? "バ" : "ハ");
+    else if(x == 0xcb) label.append(y == 0xdf ? "ピ" : y == 0xde ? "ビ" : "ヒ");
+    else if(x == 0xcc) label.append(y == 0xdf ? "プ" : y == 0xde ? "ブ" : "フ");
+    else if(x == 0xcd) label.append(y == 0xdf ? "ペ" : y == 0xde ? "ベ" : "ヘ");
+    else if(x == 0xce) label.append(y == 0xdf ? "ポ" : y == 0xde ? "ボ" : "ホ");
+
+    else if(x == 0xcf) label.append("マ");
+    else if(x == 0xd0) label.append("ミ");
+    else if(x == 0xd1) label.append("ム");
+    else if(x == 0xd2) label.append("メ");
+    else if(x == 0xd3) label.append("モ");
+
+    else if(x == 0xd4) label.append("ヤ");
+    else if(x == 0xd5) label.append("ユ");
+    else if(x == 0xd6) label.append("ヨ");
+
+    else if(x == 0xd7) label.append("ラ");
+    else if(x == 0xd8) label.append("リ");
+    else if(x == 0xd9) label.append("ル");
+    else if(x == 0xda) label.append("レ");
+    else if(x == 0xdb) label.append("ロ");
+
+    else if(x == 0xdc) label.append("ワ");
+    else if(x == 0xdd) label.append("ン");
+
+    else if(x == 0xde) label.append("\xef\xbe\x9e");  //dakuten
+    else if(x == 0xdf) label.append("\xef\xbe\x9f");  //handakuten
+
+    //unknown
+    else label.append("?");
+
+    //(han)dakuten skip
+    if(y == 0xde && x == 0xb3) n++;
+    if(y == 0xde && x >= 0xb6 && x <= 0xc4) n++;
+    if(y == 0xde && x >= 0xca && x <= 0xce) n++;
+    if(y == 0xdf && x >= 0xca && y <= 0xce) n++;
+  }
+
+  return label.strip();
+}
+
+auto SuperFamicom::serial() const -> string {
+  char A = data[headerAddress + 0x02];  //game type
+  char B = data[headerAddress + 0x03];  //game code
+  char C = data[headerAddress + 0x04];  //game code
+  char D = data[headerAddress + 0x05];  //region code (new; sometimes ambiguous)
+
+  auto valid = [](char n) { return (n >= '0' && n <= '9') || (n >= 'A' && n <= 'Z'); };
+  if(data[headerAddress + 0x2a] == 0x33 && valid(A) && valid(B) & valid(C) & valid(D)) {
+    return {A, B, C, D};
+  }
+
+  return "";
+}
+
+auto SuperFamicom::romSize() const -> uint {
+  //subtract appended firmware size, if firmware is present
+  if((size() &  0x7fff) ==   0x100) return size() -   0x100;
+  if((size() &  0x7fff) ==   0xc00) return size() -   0xc00;
+  if((size() &  0x7fff) ==  0x2000) return size() -  0x2000;
+  if((size() &  0xffff) ==  0xd000) return size() -  0xd000;
+  if((size() & 0x3ffff) == 0x28000) return size() - 0x28000;
+  return size();
+}
+
+auto SuperFamicom::programRomSize() const -> uint {
+  if(board().beginsWith("SPC7110-")) return 0x100000;
+  if(board().beginsWith("EXSPC7110-")) return 0x100000;
+  return romSize();
+}
+
+auto SuperFamicom::dataRomSize() const -> uint {
+  if(board().beginsWith("SPC7110-")) return romSize() - 0x100000;
+  if(board().beginsWith("EXSPC7110-")) return 0x500000;
+  return 0;
+}
+
+auto SuperFamicom::expansionRomSize() const -> uint {
+  if(board().beginsWith("EXSPC7110-")) return 0x100000;
+  return 0;
+}
+
+auto SuperFamicom::firmwareRomSize() const -> uint {
+  return size() - romSize();
+}
+
+auto SuperFamicom::ramSize() const -> uint {
+  auto ramSize = data[headerAddress + 0x28] & 7;
+  if(ramSize) return 1024 << ramSize;
+  return 0;
+}
+
+auto SuperFamicom::expansionRamSize() const -> uint {
+  if(data[headerAddress + 0x2a] == 0x33) {
+    auto ramSize = data[headerAddress + 0x0d] & 7;
+    if(ramSize) return 1024 << ramSize;
+  }
+  if((data[headerAddress + 0x26] >> 4) == 1) {
+    //GSU: Starfox / Starwing lacks an extended header; but still has expansion RAM
+    return 0x8000;
+  }
+  return 0;
+}
+
+auto SuperFamicom::nonVolatile() const -> bool {
+  auto cartridgeTypeLo = data[headerAddress + 0x26] & 15;
+  return cartridgeTypeLo == 0x2 || cartridgeTypeLo == 0x5 || cartridgeTypeLo == 0x6;
+}
+
+auto SuperFamicom::scoreHeader(uint address) -> uint {
+  int score = 0;
+  if(size() < address + 0x50) return score;
+
+  uint8_t  mapMode     = data[address + 0x25] & ~0x10;  //ignore FastROM bit
+  uint16_t complement  = data[address + 0x2c] << 0 | data[address + 0x2d] << 8;
+  uint16_t checksum    = data[address + 0x2e] << 0 | data[address + 0x2f] << 8;
+  uint16_t resetVector = data[address + 0x4c] << 0 | data[address + 0x4d] << 8;
+  if(resetVector < 0x8000) return score;  //$00:0000-7fff is never ROM data
+
+  uint8_t opcode = data[(address & ~0x7fff) | (resetVector & 0x7fff)];  //first instruction executed
+
+  //most likely opcodes
+  if(opcode == 0x78  //sei
+  || opcode == 0x18  //clc (clc; xce)
+  || opcode == 0x38  //sec (sec; xce)
+  || opcode == 0x9c  //stz $nnnn (stz $4200)
+  || opcode == 0x4c  //jmp $nnnn
+  || opcode == 0x5c  //jml $nnnnnn
+  ) score += 8;
+
+  //plausible opcodes
+  if(opcode == 0xc2  //rep #$nn
+  || opcode == 0xe2  //sep #$nn
+  || opcode == 0xad  //lda $nnnn
+  || opcode == 0xae  //ldx $nnnn
+  || opcode == 0xac  //ldy $nnnn
+  || opcode == 0xaf  //lda $nnnnnn
+  || opcode == 0xa9  //lda #$nn
+  || opcode == 0xa2  //ldx #$nn
+  || opcode == 0xa0  //ldy #$nn
+  || opcode == 0x20  //jsr $nnnn
+  || opcode == 0x22  //jsl $nnnnnn
+  ) score += 4;
+
+  //implausible opcodes
+  if(opcode == 0x40  //rti
+  || opcode == 0x60  //rts
+  || opcode == 0x6b  //rtl
+  || opcode == 0xcd  //cmp $nnnn
+  || opcode == 0xec  //cpx $nnnn
+  || opcode == 0xcc  //cpy $nnnn
+  ) score -= 4;
+
+  //least likely opcodes
+  if(opcode == 0x00  //brk #$nn
+  || opcode == 0x02  //cop #$nn
+  || opcode == 0xdb  //stp
+  || opcode == 0x42  //wdm
+  || opcode == 0xff  //sbc $nnnnnn,x
+  ) score -= 8;
+
+  if(checksum + complement == 0xffff) score += 4;
+
+  if(address == 0x7fb0 && mapMode == 0x20) score += 2;
+  if(address == 0xffb0 && mapMode == 0x21) score += 2;
+
+  return max(0, score);
+}
+
+auto SuperFamicom::firmwareARM() const -> string {
+  return "ST018";
+}
+
+auto SuperFamicom::firmwareEXNEC() const -> string {
+  if(title() == "EXHAUST HEAT2") return "ST010";
+  if(title() == "F1 ROC II") return "ST010";
+  if(title() == "2DAN MORITA SHOUGI") return "ST011";
+  return "ST010";
+}
+
+auto SuperFamicom::firmwareGB() const -> string {
+  if(title() == "Super GAMEBOY") return "SGB1";
+  if(title() == "Super GAMEBOY2") return "SGB2";
+  return "SGB1";
+}
+
+auto SuperFamicom::firmwareHITACHI() const -> string {
+  return "Cx4";
+}
+
+auto SuperFamicom::firmwareNEC() const -> string {
+  if(title() == "PILOTWINGS") return "DSP1";
+  if(title() == "DUNGEON MASTER") return "DSP2";
+  if(title() == "SDガンダムGX") return "DSP3";
+  if(title() == "PLANETS CHAMP TG3000") return "DSP4";
+  if(title() == "TOP GEAR 3000") return "DSP4";
+  return "DSP1B";
+}
+
+}

bsnes/lzma/7z.h

@@ -0,0 +1,202 @@
+/* 7z.h -- 7z interface
+2017-04-03 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_H
+#define __7Z_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define k7zStartHeaderSize 0x20
+#define k7zSignatureSize 6
+
+extern const Byte k7zSignature[k7zSignatureSize];
+
+typedef struct
+{
+  const Byte *Data;
+  size_t Size;
+} CSzData;
+
+/* CSzCoderInfo & CSzFolder support only default methods */
+
+typedef struct
+{
+  size_t PropsOffset;
+  UInt32 MethodID;
+  Byte NumStreams;
+  Byte PropsSize;
+} CSzCoderInfo;
+
+typedef struct
+{
+  UInt32 InIndex;
+  UInt32 OutIndex;
+} CSzBond;
+
+#define SZ_NUM_CODERS_IN_FOLDER_MAX 4
+#define SZ_NUM_BONDS_IN_FOLDER_MAX 3
+#define SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX 4
+
+typedef struct
+{
+  UInt32 NumCoders;
+  UInt32 NumBonds;
+  UInt32 NumPackStreams;
+  UInt32 UnpackStream;
+  UInt32 PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX];
+  CSzBond Bonds[SZ_NUM_BONDS_IN_FOLDER_MAX];
+  CSzCoderInfo Coders[SZ_NUM_CODERS_IN_FOLDER_MAX];
+} CSzFolder;
+
+
+SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd);
+
+typedef struct
+{
+  UInt32 Low;
+  UInt32 High;
+} CNtfsFileTime;
+
+typedef struct
+{
+  Byte *Defs; /* MSB 0 bit numbering */
+  UInt32 *Vals;
+} CSzBitUi32s;
+
+typedef struct
+{
+  Byte *Defs; /* MSB 0 bit numbering */
+  // UInt64 *Vals;
+  CNtfsFileTime *Vals;
+} CSzBitUi64s;
+
+#define SzBitArray_Check(p, i) (((p)[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
+
+#define SzBitWithVals_Check(p, i) ((p)->Defs && ((p)->Defs[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
+
+typedef struct
+{
+  UInt32 NumPackStreams;
+  UInt32 NumFolders;
+
+  UInt64 *PackPositions;          // NumPackStreams + 1
+  CSzBitUi32s FolderCRCs;         // NumFolders
+
+  size_t *FoCodersOffsets;        // NumFolders + 1
+  UInt32 *FoStartPackStreamIndex; // NumFolders + 1
+  UInt32 *FoToCoderUnpackSizes;   // NumFolders + 1
+  Byte *FoToMainUnpackSizeIndex;  // NumFolders
+  UInt64 *CoderUnpackSizes;       // for all coders in all folders
+
+  Byte *CodersData;
+} CSzAr;
+
+UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex);
+
+SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
+    ILookInStream *stream, UInt64 startPos,
+    Byte *outBuffer, size_t outSize,
+    ISzAllocPtr allocMain);
+
+typedef struct
+{
+  CSzAr db;
+
+  UInt64 startPosAfterHeader;
+  UInt64 dataPos;
+  
+  UInt32 NumFiles;
+
+  UInt64 *UnpackPositions;  // NumFiles + 1
+  // Byte *IsEmptyFiles;
+  Byte *IsDirs;
+  CSzBitUi32s CRCs;
+
+  CSzBitUi32s Attribs;
+  // CSzBitUi32s Parents;
+  CSzBitUi64s MTime;
+  CSzBitUi64s CTime;
+
+  UInt32 *FolderToFile;   // NumFolders + 1
+  UInt32 *FileToFolder;   // NumFiles
+
+  size_t *FileNameOffsets; /* in 2-byte steps */
+  Byte *FileNames;  /* UTF-16-LE */
+} CSzArEx;
+
+#define SzArEx_IsDir(p, i) (SzBitArray_Check((p)->IsDirs, i))
+
+#define SzArEx_GetFileSize(p, i) ((p)->UnpackPositions[(i) + 1] - (p)->UnpackPositions[i])
+
+void SzArEx_Init(CSzArEx *p);
+void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc);
+UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
+int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);
+
+/*
+if dest == NULL, the return value specifies the required size of the buffer,
+  in 16-bit characters, including the null-terminating character.
+if dest != NULL, the return value specifies the number of 16-bit characters that
+  are written to the dest, including the null-terminating character. */
+
+size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
+
+/*
+size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex);
+UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
+*/
+
+
+
+/*
+  SzArEx_Extract extracts file from archive
+
+  *outBuffer must be 0 before first call for each new archive.
+
+  Extracting cache:
+    If you need to decompress more than one file, you can send
+    these values from previous call:
+      *blockIndex,
+      *outBuffer,
+      *outBufferSize
+    You can consider "*outBuffer" as cache of solid block. If your archive is solid,
+    it will increase decompression speed.
+  
+    If you use external function, you can declare these 3 cache variables
+    (blockIndex, outBuffer, outBufferSize) as static in that external function.
+    
+    Free *outBuffer and set *outBuffer to 0, if you want to flush cache.
+*/
+
+SRes SzArEx_Extract(
+    const CSzArEx *db,
+    ILookInStream *inStream,
+    UInt32 fileIndex,         /* index of file */
+    UInt32 *blockIndex,       /* index of solid block */
+    Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
+    size_t *outBufferSize,    /* buffer size for output buffer */
+    size_t *offset,           /* offset of stream for required file in *outBuffer */
+    size_t *outSizeProcessed, /* size of file in *outBuffer */
+    ISzAllocPtr allocMain,
+    ISzAllocPtr allocTemp);
+
+
+/*
+SzArEx_Open Errors:
+SZ_ERROR_NO_ARCHIVE
+SZ_ERROR_ARCHIVE
+SZ_ERROR_UNSUPPORTED
+SZ_ERROR_MEM
+SZ_ERROR_CRC
+SZ_ERROR_INPUT_EOF
+SZ_ERROR_FAIL
+*/
+
+SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
+    ISzAllocPtr allocMain, ISzAllocPtr allocTemp);
+
+EXTERN_C_END
+
+#endif

bsnes/lzma/7zAlloc.c

@@ -0,0 +1,80 @@
+/* 7zAlloc.c -- Allocation functions
+2017-04-03 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <stdlib.h>
+
+#include "7zAlloc.h"
+
+/* #define _SZ_ALLOC_DEBUG */
+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
+
+#ifdef _SZ_ALLOC_DEBUG
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include <stdio.h>
+int g_allocCount = 0;
+int g_allocCountTemp = 0;
+
+#endif
+
+void *SzAlloc(ISzAllocPtr p, size_t size)
+{
+  UNUSED_VAR(p);
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc %10u bytes; count = %10d", (unsigned)size, g_allocCount);
+  g_allocCount++;
+  #endif
+  return malloc(size);
+}
+
+void SzFree(ISzAllocPtr p, void *address)
+{
+  UNUSED_VAR(p);
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+  {
+    g_allocCount--;
+    fprintf(stderr, "\nFree; count = %10d", g_allocCount);
+  }
+  #endif
+  free(address);
+}
+
+void *SzAllocTemp(ISzAllocPtr p, size_t size)
+{
+  UNUSED_VAR(p);
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc_temp %10u bytes;  count = %10d", (unsigned)size, g_allocCountTemp);
+  g_allocCountTemp++;
+  #ifdef _WIN32
+  return HeapAlloc(GetProcessHeap(), 0, size);
+  #endif
+  #endif
+  return malloc(size);
+}
+
+void SzFreeTemp(ISzAllocPtr p, void *address)
+{
+  UNUSED_VAR(p);
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+  {
+    g_allocCountTemp--;
+    fprintf(stderr, "\nFree_temp; count = %10d", g_allocCountTemp);
+  }
+  #ifdef _WIN32
+  HeapFree(GetProcessHeap(), 0, address);
+  return;
+  #endif
+  #endif
+  free(address);
+}

bsnes/lzma/7zAlloc.h

@@ -0,0 +1,19 @@
+/* 7zAlloc.h -- Allocation functions
+2017-04-03 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_ALLOC_H
+#define __7Z_ALLOC_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+void *SzAlloc(ISzAllocPtr p, size_t size);
+void SzFree(ISzAllocPtr p, void *address);
+
+void *SzAllocTemp(ISzAllocPtr p, size_t size);
+void SzFreeTemp(ISzAllocPtr p, void *address);
+
+EXTERN_C_END
+
+#endif

bsnes/lzma/7zBuf.c

@@ -0,0 +1,36 @@
+/* 7zBuf.c -- Byte Buffer
+2017-04-03 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "7zBuf.h"
+
+void Buf_Init(CBuf *p)
+{
+  p->data = 0;
+  p->size = 0;
+}
+
+int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc)
+{
+  p->size = 0;
+  if (size == 0)
+  {
+    p->data = 0;
+    return 1;
+  }
+  p->data = (Byte *)ISzAlloc_Alloc(alloc, size);
+  if (p->data)
+  {
+    p->size = size;
+    return 1;
+  }
+  return 0;
+}
+
+void Buf_Free(CBuf *p, ISzAllocPtr alloc)
+{
+  ISzAlloc_Free(alloc, p->data);
+  p->data = 0;
+  p->size = 0;
+}

bsnes/lzma/7zBuf.h

@@ -0,0 +1,35 @@
+/* 7zBuf.h -- Byte Buffer
+2017-04-03 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_BUF_H
+#define __7Z_BUF_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+typedef struct
+{
+  Byte *data;
+  size_t size;
+} CBuf;
+
+void Buf_Init(CBuf *p);
+int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc);
+void Buf_Free(CBuf *p, ISzAllocPtr alloc);
+
+typedef struct
+{
+  Byte *data;
+  size_t size;
+  size_t pos;
+} CDynBuf;
+
+void DynBuf_Construct(CDynBuf *p);
+void DynBuf_SeekToBeg(CDynBuf *p);
+int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAllocPtr alloc);
+void DynBuf_Free(CDynBuf *p, ISzAllocPtr alloc);
+
+EXTERN_C_END
+
+#endif