auto sample(P&&... p) -> void {
+ double samples[sizeof...(P)] = {forward(p)...};
+ write(samples);
+ }
+
+ auto serialize(serializer&) -> void;
+
+private:
+ struct Channel {
+ vector filters;
+ vector nyquist;
+ DSP::Resampler::Cubic resampler;
+ };
+ vector channels;
+ double inputFrequency;
+ double outputFrequency;
+
+ friend class Audio;
+};
+
+extern Audio audio;
+
+}
+
+#undef double
diff --git a/waterbox/bsnescore/bsnes/emulator/audio/stream.cpp b/waterbox/bsnescore/bsnes/emulator/audio/stream.cpp
new file mode 100644
index 0000000000..3fe659f8d3
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/emulator/audio/stream.cpp
@@ -0,0 +1,125 @@
+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::reset() -> void {
+ for(auto& channel : channels) {
+ channel.resampler.reset(this->inputFrequency, this->outputFrequency);
+ }
+}
+
+auto Stream::frequency() const -> double {
+ return inputFrequency;
+}
+
+auto Stream::setFrequency(double inputFrequency, maybe 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 -> uint {
+ if(!channels) return 0;
+ return 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();
+}
+
+auto Stream::serialize(serializer& s) -> void {
+ for(auto& channel : channels) {
+ channel.resampler.serialize(s);
+ }
+ s.real(inputFrequency);
+ s.real(outputFrequency);
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/cheat.hpp b/waterbox/bsnescore/bsnes/emulator/cheat.hpp
new file mode 100644
index 0000000000..20f194b703
--- /dev/null
+++ b/waterbox/bsnescore/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 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 compare = {}) -> void {
+ codes.append({address, data, compare});
+ }
+
+ auto assign(const vector& 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 {
+ for(auto& code : codes) {
+ if(code.address == address && (!code.compare || code.compare() == compare)) {
+ return code.data;
+ }
+ }
+ return nothing;
+ }
+
+ vector codes;
+};
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/emulator.cpp b/waterbox/bsnescore/bsnes/emulator/emulator.cpp
new file mode 100644
index 0000000000..ce4b705577
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/emulator/emulator.cpp
@@ -0,0 +1,8 @@
+#include
+#include
+
+namespace Emulator {
+
+Platform* platform = nullptr;
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/emulator.hpp b/waterbox/bsnescore/bsnes/emulator/emulator.hpp
new file mode 100644
index 0000000000..71cd809a5f
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/emulator/emulator.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+using namespace nall;
+
+#include
+#include
+#include
+#include
+
+namespace Emulator {
+ static const string Name = "bsnes";
+ static const string Version = "115";
+ static const string Copyright = "bsnes team";
+ static const string License = "GPLv3 or later";
+ static const string Website = "https://bsnes.dev";
+
+ //incremented only when serialization format changes
+ static const string SerializerVersion = "115";
+
+ 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"
diff --git a/waterbox/bsnescore/bsnes/emulator/game.hpp b/waterbox/bsnescore/bsnes/emulator/game.hpp
new file mode 100644
index 0000000000..cad2141d07
--- /dev/null
+++ b/waterbox/bsnescore/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;
+ inline auto oscillator(natural = 0) -> maybe;
+
+ 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 memoryList;
+ vector 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 {
+ 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 {
+ 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();
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/interface.hpp b/waterbox/bsnescore/bsnes/emulator/interface.hpp
new file mode 100644
index 0000000000..f21399fe4f
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/emulator/interface.hpp
@@ -0,0 +1,109 @@
+#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 { return {}; }
+ virtual auto manifests() -> vector { return {}; }
+ virtual auto titles() -> vector { 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 { return {}; }
+ virtual auto devices(uint port) -> vector { return {}; }
+ virtual auto inputs(uint device) -> vector& = {}) -> 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 {}
+
+ virtual auto runAhead() -> bool { return false; }
+ virtual auto setRunAhead(bool runAhead) -> void {}
+};
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/memory/memory.hpp b/waterbox/bsnescore/bsnes/emulator/memory/memory.hpp
new file mode 100644
index 0000000000..8e6ce4b233
--- /dev/null
+++ b/waterbox/bsnescore/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;
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/memory/readable.hpp b/waterbox/bsnescore/bsnes/emulator/memory/readable.hpp
new file mode 100644
index 0000000000..688a2df694
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/emulator/memory/readable.hpp
@@ -0,0 +1,63 @@
+#pragma once
+
+#include
+
+namespace Emulator::Memory {
+
+template
+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(self.data, self.mask + 1, fill);
+ }
+
+ inline auto load(shared_pointer 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 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;
+};
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/memory/writable.hpp b/waterbox/bsnescore/bsnes/emulator/memory/writable.hpp
new file mode 100644
index 0000000000..8ae5bd984f
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/emulator/memory/writable.hpp
@@ -0,0 +1,65 @@
+#pragma once
+
+#include
+
+namespace Emulator::Memory {
+
+template
+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(self.data, self.mask + 1, fill);
+ }
+
+ inline auto load(shared_pointer 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 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;
+};
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/platform.hpp b/waterbox/bsnescore/bsnes/emulator/platform.hpp
new file mode 100644
index 0000000000..0cde99a938
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/emulator/platform.hpp
@@ -0,0 +1,34 @@
+#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 { return {}; }
+ virtual auto load(uint id, string name, string type, vector options = {}) -> Load { return {}; }
+ virtual auto videoFrame(const uint16* data, uint pitch, uint width, uint height, uint scale) -> void {}
+ virtual auto audioFrame(const double* 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 {}
+ // 03-may-2021 manual addition. unused currently but let's hope for the best
+ virtual auto getBackdropColor() -> uint16 { return 0; }
+
+ bool traceEnabled = false;
+ virtual auto cpuTrace(vector) -> void {}
+};
+
+extern Platform* platform;
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/random.hpp b/waterbox/bsnescore/bsnes/emulator/random.hpp
new file mode 100644
index 0000000000..b6228877f0
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/emulator/random.hpp
@@ -0,0 +1,96 @@
+#pragma once
+
+namespace Emulator {
+
+struct Random {
+ enum class Entropy : uint { None, Low, High };
+
+ auto operator()() -> uint64 {
+ return random();
+ }
+
+ auto entropy(Entropy entropy) -> void {
+ _entropy = entropy;
+ seed();
+ }
+
+ auto seed(maybe seed = nothing, maybe sequence = nothing) -> void {
+ if(!seed) seed = (uint32)clock();
+ if(!sequence) sequence = 0;
+
+ _state = 0;
+ _increment = sequence() << 1 | 1;
+ step();
+ _state += seed();
+ step();
+ }
+
+ auto random() -> uint64 {
+ if(_entropy == Entropy::None) return 0;
+ return (uint64)step() << 32 | (uint64)step() << 0;
+ }
+
+ auto bias(uint64 bias) -> uint64 {
+ if(_entropy == Entropy::None) return bias;
+ return random();
+ }
+
+ auto bound(uint64 bound) -> uint64 {
+ uint64 threshold = -bound % bound;
+ while(true) {
+ uint64 result = random();
+ if(result >= threshold) return result % bound;
+ }
+ }
+
+ auto array(uint8* data, uint32 size) -> void {
+ if(_entropy == Entropy::None) {
+ memory::fill(data, size);
+ return;
+ }
+
+ if(_entropy == Entropy::High) {
+ for(uint32 address : range(size)) {
+ data[address] = random();
+ }
+ return;
+ }
+
+ //Entropy::Low
+ uint lobit = random() & 3;
+ uint hibit = (lobit + 8 + (random() & 3)) & 15;
+ uint lovalue = random() & 255;
+ uint hivalue = random() & 255;
+ if((random() & 3) == 0) lovalue = 0;
+ if((random() & 1) == 0) hivalue = ~lovalue;
+
+ for(uint32 address : range(size)) {
+ 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;
+ }
+ }
+
+ auto serialize(serializer& s) -> void {
+ s.integer((uint&)_entropy);
+ s.integer(_state);
+ s.integer(_increment);
+ }
+
+private:
+ auto step() -> uint32 {
+ uint64 state = _state;
+ _state = state * 6364136223846793005ull + _increment;
+ uint32 xorshift = (state >> 18 ^ state) >> 27;
+ uint32 rotate = state >> 59;
+ return xorshift >> rotate | xorshift << (-rotate & 31);
+ }
+
+ Entropy _entropy = Entropy::High;
+ uint64 _state;
+ uint64 _increment;
+};
+
+}
diff --git a/waterbox/bsnescore/bsnes/emulator/types.hpp b/waterbox/bsnescore/bsnes/emulator/types.hpp
new file mode 100644
index 0000000000..6c1fcda851
--- /dev/null
+++ b/waterbox/bsnescore/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;
diff --git a/waterbox/bsnescore/bsnes/gb/Core/apu.c b/waterbox/bsnescore/bsnes/gb/Core/apu.c
new file mode 100644
index 0000000000..7e7ab31f66
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/apu.c
@@ -0,0 +1,1064 @@
+#include
+#include
+#include
+#include
+#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 uint8_t agb_bias_for_channel(GB_gameboy_t *gb, unsigned index)
+{
+ if (!gb->apu.is_active[index]) return 0;
+
+ switch (index) {
+ case GB_SQUARE_1:
+ return gb->apu.square_channels[GB_SQUARE_1].current_volume;
+ case GB_SQUARE_2:
+ return gb->apu.square_channels[GB_SQUARE_2].current_volume;
+ case GB_WAVE:
+ return 0;
+ case GB_NOISE:
+ return gb->apu.noise_channel.current_volume;
+ }
+ return 0;
+}
+
+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;
+ uint8_t bias = agb_bias_for_channel(gb, index);
+
+ if (gb->io_registers[GB_IO_NR51] & (1 << index)) {
+ output.right = (0xf - value * 2 + bias) * right_volume;
+ }
+ else {
+ output.right = 0xf * right_volume;
+ }
+
+ if (gb->io_registers[GB_IO_NR51] & (0x10 << index)) {
+ output.left = (0xf - value * 2 + bias) * 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_length(GB_gameboy_t *gb)
+{
+ uint16_t delta = gb->apu.shadow_sweep_sample_length >> (gb->io_registers[GB_IO_NR10] & 7);
+ if (gb->io_registers[GB_IO_NR10] & 8) {
+ return gb->apu.shadow_sweep_sample_length - delta;
+ }
+ return gb->apu.shadow_sweep_sample_length + 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 (gb->cgb_double_speed) {
+ if (index == GB_SQUARE_1) {
+ gb->apu.pcm_mask[0] &= gb->apu.square_channels[GB_SQUARE_1].current_volume | 0xF1;
+ }
+ else {
+ gb->apu.pcm_mask[0] &= (gb->apu.square_channels[GB_SQUARE_2].current_volume << 2) | 0x1F;
+ }
+ }
+
+ 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 || !--gb->apu.noise_channel.volume_countdown) {
+ if (gb->cgb_double_speed) {
+ gb->apu.pcm_mask[0] &= (gb->apu.noise_channel.current_volume << 2) | 0x1F;
+ }
+ 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_SKIP_DIV_EVENT_SKIP) {
+ gb->apu.skip_div_event = GB_SKIP_DIV_EVENT_SKIPPED;
+ return;
+ }
+ if (gb->apu.skip_div_event == GB_SKIP_DIV_EVENT_SKIPPED) {
+ gb->apu.skip_div_event = GB_SKIP_DIV_EVENT_INACTIVE;
+ }
+ else {
+ 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_length =
+ gb->apu.new_sweep_sample_length;
+ }
+
+ 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_length = new_sweep_sample_length(gb);
+ if (gb->apu.new_sweep_sample_length > 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;
+ if (cycles_left == 0 && gb->apu.samples[i] == 0) {
+ gb->apu.pcm_mask[0] &= i == GB_SQUARE_1? 0xF0 : 0x0F;
+ }
+
+ 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;
+ 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;
+
+ if (cycles_left == 0 && gb->apu.samples[GB_NOISE] == 0) {
+ gb->apu.pcm_mask[1] &= 0x0F;
+ }
+
+ 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 = GB_SKIP_DIV_EVENT_SKIP;
+ gb->apu.div_divider = 1;
+ }
+}
+
+uint8_t GB_apu_read(GB_gameboy_t *gb, uint8_t reg)
+{
+ if (reg == GB_IO_NR52) {
+ uint8_t value = 0;
+ for (unsigned 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;
+
+ /* TODO: When the sample length changes right before being updated, the countdown should change to the
+ old length, but the current sample should not change. Because our write timing isn't accurate to
+ the T-cycle, we hack around it by stepping the sample index backwards. */
+ if ((value & 0x80) == 0 && gb->apu.is_active[index]) {
+ /* On an AGB, as well as on CGB C and earlier (TODO: Tested: 0, B and C), it behaves slightly different on
+ double speed. */
+ if (gb->model == GB_MODEL_CGB_E /* || gb->model == GB_MODEL_CGB_D */ || gb->apu.square_channels[index].sample_countdown & 1) {
+ if (gb->apu.square_channels[index].sample_countdown >> 1 == (gb->apu.square_channels[index].sample_length ^ 0x7FF)) {
+ gb->apu.square_channels[index].current_sample_index--;
+ gb->apu.square_channels[index].current_sample_index &= 7;
+ }
+ }
+ }
+
+ 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_length =
+ gb->apu.new_sweep_sample_length =
+ 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_output.rate_set_in_clocks = false;
+ GB_apu_update_cycles_per_sample(gb);
+}
+
+void GB_set_sample_rate_by_clocks(GB_gameboy_t *gb, double cycles_per_sample)
+{
+
+ if (cycles_per_sample == 0) {
+ GB_set_sample_rate(gb, 0);
+ return;
+ }
+ gb->apu_output.cycles_per_sample = cycles_per_sample;
+ gb->apu_output.sample_rate = GB_get_clock_rate(gb) / cycles_per_sample * 2;
+ gb->apu_output.highpass_rate = pow(0.999958, cycles_per_sample);
+ gb->apu_output.rate_set_in_clocks = true;
+}
+
+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.rate_set_in_clocks) return;
+ 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 */
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/apu.h b/waterbox/bsnescore/bsnes/gb/Core/apu.h
new file mode 100644
index 0000000000..a3a36a63f6
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/apu.h
@@ -0,0 +1,169 @@
+#ifndef apu_h
+#define apu_h
+#include
+#include
+#include
+#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_length;
+ uint16_t shadow_sweep_sample_length;
+ 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;
+
+#define GB_SKIP_DIV_EVENT_INACTIVE 0
+#define GB_SKIP_DIV_EVENT_SKIPPED 1
+#define GB_SKIP_DIV_EVENT_SKIP 2
+ uint8_t skip_div_event;
+ bool current_lfsr_sample;
+ uint8_t pcm_mask[2]; // For CGB-0 to CGB-C PCM read glitch
+} 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;
+
+ bool rate_set_in_clocks;
+} GB_apu_output_t;
+
+void GB_set_sample_rate(GB_gameboy_t *gb, unsigned sample_rate);
+void GB_set_sample_rate_by_clocks(GB_gameboy_t *gb, double cycles_per_sample); /* Cycles are in 8MHz units */
+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);
+void GB_borrow_sgb_border(GB_gameboy_t *gb);
+#endif
+
+#endif /* apu_h */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/camera.c b/waterbox/bsnescore/bsnes/gb/Core/camera.c
new file mode 100644
index 0000000000..bef84890cd
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/camera.c
@@ -0,0 +1,149 @@
+#include "gb.h"
+
+static signed 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)
+{
+ signed value = (x + y * 128 + noise_seed);
+ uint8_t *data = (uint8_t *) &value;
+ unsigned hash = 0;
+
+ while ((signed *) 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;
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/camera.h b/waterbox/bsnescore/bsnes/gb/Core/camera.h
new file mode 100644
index 0000000000..21c69b68e6
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/camera.h
@@ -0,0 +1,29 @@
+#ifndef camera_h
+#define camera_h
+#include
+#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
diff --git a/waterbox/bsnescore/bsnes/gb/Core/cheats.c b/waterbox/bsnescore/bsnes/gb/Core/cheats.c
new file mode 100644
index 0000000000..14875e0101
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/cheats.c
@@ -0,0 +1,313 @@
+#include "gb.h"
+#include "cheats.h"
+#include
+#include
+#include
+
+static inline uint8_t hash_addr(uint16_t addr)
+{
+ return addr;
+}
+
+static uint16_t bank_for_addr(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (addr < 0x4000) {
+ return gb->mbc_rom0_bank;
+ }
+
+ if (addr < 0x8000) {
+ return gb->mbc_rom_bank;
+ }
+
+ if (addr < 0xD000) {
+ return 0;
+ }
+
+ if (addr < 0xE000) {
+ return gb->cgb_ram_bank;
+ }
+
+ return 0;
+}
+
+void GB_apply_cheat(GB_gameboy_t *gb, uint16_t address, uint8_t *value)
+{
+ if (!gb->cheat_enabled) return;
+ if (!gb->boot_rom_finished) return;
+ const GB_cheat_hash_t *hash = gb->cheat_hash[hash_addr(address)];
+ if (hash) {
+ for (unsigned i = 0; i < hash->size; i++) {
+ GB_cheat_t *cheat = hash->cheats[i];
+ if (cheat->address == address && cheat->enabled && (!cheat->use_old_value || cheat->old_value == *value)) {
+ if (cheat->bank == GB_CHEAT_ANY_BANK || cheat->bank == bank_for_addr(gb, address)) {
+ *value = cheat->value;
+ break;
+ }
+ }
+ }
+ }
+}
+
+bool GB_cheats_enabled(GB_gameboy_t *gb)
+{
+ return gb->cheat_enabled;
+}
+
+void GB_set_cheats_enabled(GB_gameboy_t *gb, bool enabled)
+{
+ gb->cheat_enabled = enabled;
+}
+
+void GB_add_cheat(GB_gameboy_t *gb, const char *description, uint16_t address, uint16_t bank, uint8_t value, uint8_t old_value, bool use_old_value, bool enabled)
+{
+ GB_cheat_t *cheat = malloc(sizeof(*cheat));
+ cheat->address = address;
+ cheat->bank = bank;
+ cheat->value = value;
+ cheat->old_value = old_value;
+ cheat->use_old_value = use_old_value;
+ cheat->enabled = enabled;
+ strncpy(cheat->description, description, sizeof(cheat->description));
+ cheat->description[sizeof(cheat->description) - 1] = 0;
+ gb->cheats = realloc(gb->cheats, (++gb->cheat_count) * sizeof(*cheat));
+ gb->cheats[gb->cheat_count - 1] = cheat;
+
+ GB_cheat_hash_t **hash = &gb->cheat_hash[hash_addr(address)];
+ if (!*hash) {
+ *hash = malloc(sizeof(GB_cheat_hash_t) + sizeof(cheat));
+ (*hash)->size = 1;
+ (*hash)->cheats[0] = cheat;
+ }
+ else {
+ (*hash)->size++;
+ *hash = realloc(*hash, sizeof(GB_cheat_hash_t) + sizeof(cheat) * (*hash)->size);
+ (*hash)->cheats[(*hash)->size - 1] = cheat;
+ }
+}
+
+const GB_cheat_t *const *GB_get_cheats(GB_gameboy_t *gb, size_t *size)
+{
+ *size = gb->cheat_count;
+ return (void *)gb->cheats;
+}
+void GB_remove_cheat(GB_gameboy_t *gb, const GB_cheat_t *cheat)
+{
+ for (unsigned i = 0; i < gb->cheat_count; i++) {
+ if (gb->cheats[i] == cheat) {
+ gb->cheats[i] = gb->cheats[--gb->cheat_count];
+ if (gb->cheat_count == 0) {
+ free(gb->cheats);
+ gb->cheats = NULL;
+ }
+ else {
+ gb->cheats = realloc(gb->cheats, gb->cheat_count * sizeof(*cheat));
+ }
+ break;
+ }
+ }
+
+ GB_cheat_hash_t **hash = &gb->cheat_hash[hash_addr(cheat->address)];
+ for (unsigned i = 0; i < (*hash)->size; i++) {
+ if ((*hash)->cheats[i] == cheat) {
+ (*hash)->cheats[i] = (*hash)->cheats[(*hash)->size--];
+ if ((*hash)->size == 0) {
+ free(*hash);
+ *hash = NULL;
+ }
+ else {
+ *hash = malloc(sizeof(GB_cheat_hash_t) + sizeof(cheat) * (*hash)->size);
+ }
+ break;
+ }
+ }
+
+ free((void *)cheat);
+}
+
+bool GB_import_cheat(GB_gameboy_t *gb, const char *cheat, const char *description, bool enabled)
+{
+ uint8_t dummy;
+ /* GameShark */
+ {
+ uint8_t bank;
+ uint8_t value;
+ uint16_t address;
+ if (sscanf(cheat, "%02hhx%02hhx%04hx%c", &bank, &value, &address, &dummy) == 3) {
+ if (bank >= 0x80) {
+ bank &= 0xF;
+ }
+ GB_add_cheat(gb, description, address, bank, value, 0, false, enabled);
+ return true;
+ }
+ }
+
+ /* GameGenie */
+ {
+ char stripped_cheat[10] = {0,};
+ for (unsigned i = 0; i < 9 && *cheat; i++) {
+ stripped_cheat[i] = *(cheat++);
+ while (*cheat == '-') {
+ cheat++;
+ }
+ }
+
+ // Delete the 7th character;
+ stripped_cheat[7] = stripped_cheat[8];
+ stripped_cheat[8] = 0;
+
+ uint8_t old_value;
+ uint8_t value;
+ uint16_t address;
+ if (sscanf(stripped_cheat, "%02hhx%04hx%02hhx%c", &value, &address, &old_value, &dummy) == 3) {
+ address = (uint16_t)(address >> 4) | (uint16_t)(address << 12);
+ address ^= 0xF000;
+ if (address > 0x7FFF) {
+ return false;
+ }
+ old_value = (uint8_t)(old_value >> 2) | (uint8_t)(old_value << 6);
+ old_value ^= 0xBA;
+ GB_add_cheat(gb, description, address, GB_CHEAT_ANY_BANK, value, old_value, true, enabled);
+ return true;
+ }
+
+ if (sscanf(stripped_cheat, "%02hhx%04hx%c", &value, &address, &dummy) == 2) {
+ address = (uint16_t)(address >> 4) | (uint16_t)(address << 12);
+ address ^= 0xF000;
+ if (address > 0x7FFF) {
+ return false;
+ }
+ GB_add_cheat(gb, description, address, GB_CHEAT_ANY_BANK, value, false, true, enabled);
+ return true;
+ }
+ }
+ return false;
+}
+
+void GB_update_cheat(GB_gameboy_t *gb, const GB_cheat_t *_cheat, const char *description, uint16_t address, uint16_t bank, uint8_t value, uint8_t old_value, bool use_old_value, bool enabled)
+{
+ GB_cheat_t *cheat = NULL;
+ for (unsigned i = 0; i < gb->cheat_count; i++) {
+ if (gb->cheats[i] == _cheat) {
+ cheat = gb->cheats[i];
+ break;
+ }
+ }
+
+ assert(cheat);
+
+ if (cheat->address != address) {
+ /* Remove from old bucket */
+ GB_cheat_hash_t **hash = &gb->cheat_hash[hash_addr(cheat->address)];
+ for (unsigned i = 0; i < (*hash)->size; i++) {
+ if ((*hash)->cheats[i] == cheat) {
+ (*hash)->cheats[i] = (*hash)->cheats[(*hash)->size--];
+ if ((*hash)->size == 0) {
+ free(*hash);
+ *hash = NULL;
+ }
+ else {
+ *hash = malloc(sizeof(GB_cheat_hash_t) + sizeof(cheat) * (*hash)->size);
+ }
+ break;
+ }
+ }
+ cheat->address = address;
+
+ /* Add to new bucket */
+ hash = &gb->cheat_hash[hash_addr(address)];
+ if (!*hash) {
+ *hash = malloc(sizeof(GB_cheat_hash_t) + sizeof(cheat));
+ (*hash)->size = 1;
+ (*hash)->cheats[0] = cheat;
+ }
+ else {
+ (*hash)->size++;
+ *hash = malloc(sizeof(GB_cheat_hash_t) + sizeof(cheat) * (*hash)->size);
+ (*hash)->cheats[(*hash)->size - 1] = cheat;
+ }
+ }
+ cheat->bank = bank;
+ cheat->value = value;
+ cheat->old_value = old_value;
+ cheat->use_old_value = use_old_value;
+ cheat->enabled = enabled;
+ if (description != cheat->description) {
+ strncpy(cheat->description, description, sizeof(cheat->description));
+ cheat->description[sizeof(cheat->description) - 1] = 0;
+ }
+}
+
+#define CHEAT_MAGIC 'SBCh'
+
+void GB_load_cheats(GB_gameboy_t *gb, const char *path)
+{
+ FILE *f = fopen(path, "rb");
+ if (!f) {
+ return;
+ }
+
+ uint32_t magic = 0;
+ uint32_t struct_size = 0;
+ fread(&magic, sizeof(magic), 1, f);
+ fread(&struct_size, sizeof(struct_size), 1, f);
+ if (magic != CHEAT_MAGIC && magic != __builtin_bswap32(CHEAT_MAGIC)) {
+ GB_log(gb, "The file is not a SameBoy cheat database");
+ return;
+ }
+
+ if (struct_size != sizeof(GB_cheat_t)) {
+ GB_log(gb, "This cheat database is not compatible with this version of SameBoy");
+ return;
+ }
+
+ // Remove all cheats first
+ while (gb->cheats) {
+ GB_remove_cheat(gb, gb->cheats[0]);
+ }
+
+ GB_cheat_t cheat;
+ while (fread(&cheat, sizeof(cheat), 1, f)) {
+ if (magic == __builtin_bswap32(CHEAT_MAGIC)) {
+ cheat.address = __builtin_bswap16(cheat.address);
+ cheat.bank = __builtin_bswap16(cheat.bank);
+ }
+ cheat.description[sizeof(cheat.description) - 1] = 0;
+ GB_add_cheat(gb, cheat.description, cheat.address, cheat.bank, cheat.value, cheat.old_value, cheat.use_old_value, cheat.enabled);
+ }
+
+ return;
+}
+
+int GB_save_cheats(GB_gameboy_t *gb, const char *path)
+{
+ if (!gb->cheat_count) return 0; // Nothing to save.
+ FILE *f = fopen(path, "wb");
+ if (!f) {
+ GB_log(gb, "Could not dump cheat database: %s.\n", strerror(errno));
+ return errno;
+ }
+
+ uint32_t magic = CHEAT_MAGIC;
+ uint32_t struct_size = sizeof(GB_cheat_t);
+
+ if (fwrite(&magic, sizeof(magic), 1, f) != 1) {
+ fclose(f);
+ return EIO;
+ }
+
+ if (fwrite(&struct_size, sizeof(struct_size), 1, f) != 1) {
+ fclose(f);
+ return EIO;
+ }
+
+ for (size_t i = 0; i cheat_count; i++) {
+ if (fwrite(gb->cheats[i], sizeof(*gb->cheats[i]), 1, f) != 1) {
+ fclose(f);
+ return EIO;
+ }
+ }
+
+ errno = 0;
+ fclose(f);
+ return errno;
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/cheats.h b/waterbox/bsnescore/bsnes/gb/Core/cheats.h
new file mode 100644
index 0000000000..cf8aa20d92
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/cheats.h
@@ -0,0 +1,42 @@
+#ifndef cheats_h
+#define cheats_h
+#include "gb_struct_def.h"
+
+#define GB_CHEAT_ANY_BANK 0xFFFF
+
+typedef struct GB_cheat_s GB_cheat_t;
+
+void GB_add_cheat(GB_gameboy_t *gb, const char *description, uint16_t address, uint16_t bank, uint8_t value, uint8_t old_value, bool use_old_value, bool enabled);
+void GB_update_cheat(GB_gameboy_t *gb, const GB_cheat_t *cheat, const char *description, uint16_t address, uint16_t bank, uint8_t value, uint8_t old_value, bool use_old_value, bool enabled);
+bool GB_import_cheat(GB_gameboy_t *gb, const char *cheat, const char *description, bool enabled);
+const GB_cheat_t *const *GB_get_cheats(GB_gameboy_t *gb, size_t *size);
+void GB_remove_cheat(GB_gameboy_t *gb, const GB_cheat_t *cheat);
+bool GB_cheats_enabled(GB_gameboy_t *gb);
+void GB_set_cheats_enabled(GB_gameboy_t *gb, bool enabled);
+void GB_load_cheats(GB_gameboy_t *gb, const char *path);
+int GB_save_cheats(GB_gameboy_t *gb, const char *path);
+
+#ifdef GB_INTERNAL
+#ifdef GB_DISABLE_CHEATS
+#define GB_apply_cheat(...)
+#else
+void GB_apply_cheat(GB_gameboy_t *gb, uint16_t address, uint8_t *value);
+#endif
+#endif
+
+typedef struct {
+ size_t size;
+ GB_cheat_t *cheats[];
+} GB_cheat_hash_t;
+
+struct GB_cheat_s {
+ uint16_t address;
+ uint16_t bank;
+ uint8_t value;
+ uint8_t old_value;
+ bool use_old_value;
+ bool enabled;
+ char description[128];
+};
+
+#endif
diff --git a/waterbox/bsnescore/bsnes/gb/Core/debugger.c b/waterbox/bsnescore/bsnes/gb/Core/debugger.c
new file mode 100644
index 0000000000..002d455454
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/debugger.c
@@ -0,0 +1,2668 @@
+#include
+#include
+#include
+#include "gb.h"
+
+typedef struct {
+ bool has_bank;
+ uint16_t bank:9;
+ uint16_t value;
+} value_t;
+
+typedef struct {
+ enum {
+ LVALUE_MEMORY,
+ LVALUE_MEMORY16,
+ LVALUE_REG16,
+ LVALUE_REG_H,
+ LVALUE_REG_L,
+ } kind;
+ union {
+ uint16_t *register_address;
+ value_t memory_address;
+ };
+} lvalue_t;
+
+#define VALUE_16(x) ((value_t){false, 0, (x)})
+
+struct GB_breakpoint_s {
+ union {
+ struct {
+ uint16_t addr;
+ uint16_t bank; /* -1 = any bank*/
+ };
+ uint32_t key; /* For sorting and comparing */
+ };
+ char *condition;
+ bool is_jump_to;
+};
+
+#define BP_KEY(x) (((struct GB_breakpoint_s){.addr = ((x).value), .bank = (x).has_bank? (x).bank : -1 }).key)
+
+#define GB_WATCHPOINT_R (1)
+#define GB_WATCHPOINT_W (2)
+
+struct GB_watchpoint_s {
+ union {
+ struct {
+ uint16_t addr;
+ uint16_t bank; /* -1 = any bank*/
+ };
+ uint32_t key; /* For sorting and comparing */
+ };
+ char *condition;
+ uint8_t flags;
+};
+
+#define WP_KEY(x) (((struct GB_watchpoint_s){.addr = ((x).value), .bank = (x).has_bank? (x).bank : -1 }).key)
+
+static uint16_t bank_for_addr(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (addr < 0x4000) {
+ return gb->mbc_rom0_bank;
+ }
+
+ if (addr < 0x8000) {
+ return gb->mbc_rom_bank;
+ }
+
+ if (addr < 0xD000) {
+ return 0;
+ }
+
+ if (addr < 0xE000) {
+ return gb->cgb_ram_bank;
+ }
+
+ return 0;
+}
+
+typedef struct {
+ uint16_t rom0_bank;
+ uint16_t rom_bank;
+ uint8_t mbc_ram_bank;
+ bool mbc_ram_enable;
+ uint8_t ram_bank;
+ uint8_t vram_bank;
+} banking_state_t;
+
+static inline void save_banking_state(GB_gameboy_t *gb, banking_state_t *state)
+{
+ state->rom0_bank = gb->mbc_rom0_bank;
+ state->rom_bank = gb->mbc_rom_bank;
+ state->mbc_ram_bank = gb->mbc_ram_bank;
+ state->mbc_ram_enable = gb->mbc_ram_enable;
+ state->ram_bank = gb->cgb_ram_bank;
+ state->vram_bank = gb->cgb_vram_bank;
+}
+
+static inline void restore_banking_state(GB_gameboy_t *gb, banking_state_t *state)
+{
+
+ gb->mbc_rom0_bank = state->rom0_bank;
+ gb->mbc_rom_bank = state->rom_bank;
+ gb->mbc_ram_bank = state->mbc_ram_bank;
+ gb->mbc_ram_enable = state->mbc_ram_enable;
+ gb->cgb_ram_bank = state->ram_bank;
+ gb->cgb_vram_bank = state->vram_bank;
+}
+
+static inline void switch_banking_state(GB_gameboy_t *gb, uint16_t bank)
+{
+ gb->mbc_rom0_bank = bank;
+ gb->mbc_rom_bank = bank;
+ gb->mbc_ram_bank = bank;
+ gb->mbc_ram_enable = true;
+ if (GB_is_cgb(gb)) {
+ gb->cgb_ram_bank = bank & 7;
+ gb->cgb_vram_bank = bank & 1;
+ if (gb->cgb_ram_bank == 0) {
+ gb->cgb_ram_bank = 1;
+ }
+ }
+}
+
+static const char *value_to_string(GB_gameboy_t *gb, uint16_t value, bool prefer_name)
+{
+ static __thread char output[256];
+ const GB_bank_symbol_t *symbol = GB_debugger_find_symbol(gb, value);
+
+ if (symbol && (value - symbol->addr > 0x1000 || symbol->addr == 0) ) {
+ symbol = NULL;
+ }
+
+ /* Avoid overflow */
+ if (symbol && strlen(symbol->name) >= 240) {
+ symbol = NULL;
+ }
+
+ if (!symbol) {
+ sprintf(output, "$%04x", value);
+ }
+
+ else if (symbol->addr == value) {
+ if (prefer_name) {
+ sprintf(output, "%s ($%04x)", symbol->name, value);
+ }
+ else {
+ sprintf(output, "$%04x (%s)", value, symbol->name);
+ }
+ }
+
+ else {
+ if (prefer_name) {
+ sprintf(output, "%s+$%03x ($%04x)", symbol->name, value - symbol->addr, value);
+ }
+ else {
+ sprintf(output, "$%04x (%s+$%03x)", value, symbol->name, value - symbol->addr);
+ }
+ }
+ return output;
+}
+
+static const char *debugger_value_to_string(GB_gameboy_t *gb, value_t value, bool prefer_name)
+{
+ if (!value.has_bank) return value_to_string(gb, value.value, prefer_name);
+
+ static __thread char output[256];
+ const GB_bank_symbol_t *symbol = GB_map_find_symbol(gb->bank_symbols[value.bank], value.value);
+
+ if (symbol && (value.value - symbol->addr > 0x1000 || symbol->addr == 0) ) {
+ symbol = NULL;
+ }
+
+ /* Avoid overflow */
+ if (symbol && strlen(symbol->name) >= 240) {
+ symbol = NULL;
+ }
+
+ if (!symbol) {
+ sprintf(output, "$%02x:$%04x", value.bank, value.value);
+ }
+
+ else if (symbol->addr == value.value) {
+ if (prefer_name) {
+ sprintf(output, "%s ($%02x:$%04x)", symbol->name, value.bank, value.value);
+ }
+ else {
+ sprintf(output, "$%02x:$%04x (%s)", value.bank, value.value, symbol->name);
+ }
+ }
+
+ else {
+ if (prefer_name) {
+ sprintf(output, "%s+$%03x ($%02x:$%04x)", symbol->name, value.value - symbol->addr, value.bank, value.value);
+ }
+ else {
+ sprintf(output, "$%02x:$%04x (%s+$%03x)", value.bank, value.value, symbol->name, value.value - symbol->addr);
+ }
+ }
+ return output;
+}
+
+static value_t read_lvalue(GB_gameboy_t *gb, lvalue_t lvalue)
+{
+ /* Not used until we add support for operators like += */
+ switch (lvalue.kind) {
+ case LVALUE_MEMORY:
+ if (lvalue.memory_address.has_bank) {
+ banking_state_t state;
+ save_banking_state(gb, &state);
+ switch_banking_state(gb, lvalue.memory_address.bank);
+ value_t r = VALUE_16(GB_read_memory(gb, lvalue.memory_address.value));
+ restore_banking_state(gb, &state);
+ return r;
+ }
+ return VALUE_16(GB_read_memory(gb, lvalue.memory_address.value));
+
+ case LVALUE_MEMORY16:
+ if (lvalue.memory_address.has_bank) {
+ banking_state_t state;
+ save_banking_state(gb, &state);
+ switch_banking_state(gb, lvalue.memory_address.bank);
+ value_t r = VALUE_16(GB_read_memory(gb, lvalue.memory_address.value) |
+ (GB_read_memory(gb, lvalue.memory_address.value + 1) * 0x100));
+ restore_banking_state(gb, &state);
+ return r;
+ }
+ return VALUE_16(GB_read_memory(gb, lvalue.memory_address.value) |
+ (GB_read_memory(gb, lvalue.memory_address.value + 1) * 0x100));
+
+ case LVALUE_REG16:
+ return VALUE_16(*lvalue.register_address);
+
+ case LVALUE_REG_L:
+ return VALUE_16(*lvalue.register_address & 0x00FF);
+
+ case LVALUE_REG_H:
+ return VALUE_16(*lvalue.register_address >> 8);
+ }
+
+ return VALUE_16(0);
+}
+
+static void write_lvalue(GB_gameboy_t *gb, lvalue_t lvalue, uint16_t value)
+{
+ switch (lvalue.kind) {
+ case LVALUE_MEMORY:
+ if (lvalue.memory_address.has_bank) {
+ banking_state_t state;
+ save_banking_state(gb, &state);
+ switch_banking_state(gb, lvalue.memory_address.bank);
+ GB_write_memory(gb, lvalue.memory_address.value, value);
+ restore_banking_state(gb, &state);
+ return;
+ }
+ GB_write_memory(gb, lvalue.memory_address.value, value);
+ return;
+
+ case LVALUE_MEMORY16:
+ if (lvalue.memory_address.has_bank) {
+ banking_state_t state;
+ save_banking_state(gb, &state);
+ switch_banking_state(gb, lvalue.memory_address.bank);
+ GB_write_memory(gb, lvalue.memory_address.value, value);
+ GB_write_memory(gb, lvalue.memory_address.value + 1, value >> 8);
+ restore_banking_state(gb, &state);
+ return;
+ }
+ GB_write_memory(gb, lvalue.memory_address.value, value);
+ GB_write_memory(gb, lvalue.memory_address.value + 1, value >> 8);
+ return;
+
+ case LVALUE_REG16:
+ *lvalue.register_address = value;
+ return;
+
+ case LVALUE_REG_L:
+ *lvalue.register_address &= 0xFF00;
+ *lvalue.register_address |= value & 0xFF;
+ return;
+
+ case LVALUE_REG_H:
+ *lvalue.register_address &= 0x00FF;
+ *lvalue.register_address |= value << 8;
+ return;
+ }
+}
+
+/* 16 bit value 16 bit value = 16 bit value
+ 25 bit address 16 bit value = 25 bit address
+ 16 bit value 25 bit address = 25 bit address
+ 25 bit address 25 bit address = 16 bit value (since adding pointers, for examples, makes no sense)
+
+ Boolean operators always return a 16-bit value
+ */
+#define FIX_BANK(x) ((value_t){a.has_bank ^ b.has_bank, a.has_bank? a.bank : b.bank, (x)})
+
+static value_t add(value_t a, value_t b) {return FIX_BANK(a.value + b.value);}
+static value_t sub(value_t a, value_t b) {return FIX_BANK(a.value - b.value);}
+static value_t mul(value_t a, value_t b) {return FIX_BANK(a.value * b.value);}
+static value_t _div(value_t a, value_t b)
+{
+ if (b.value == 0) {
+ return FIX_BANK(0);
+ }
+ return FIX_BANK(a.value / b.value);
+};
+static value_t mod(value_t a, value_t b)
+{
+ if (b.value == 0) {
+ return FIX_BANK(0);
+ }
+ return FIX_BANK(a.value % b.value);
+};
+static value_t and(value_t a, value_t b) {return FIX_BANK(a.value & b.value);}
+static value_t or(value_t a, value_t b) {return FIX_BANK(a.value | b.value);}
+static value_t xor(value_t a, value_t b) {return FIX_BANK(a.value ^ b.value);}
+static value_t shleft(value_t a, value_t b) {return FIX_BANK(a.value << b.value);}
+static value_t shright(value_t a, value_t b) {return FIX_BANK(a.value >> b.value);}
+static value_t assign(GB_gameboy_t *gb, lvalue_t a, uint16_t b)
+{
+ write_lvalue(gb, a, b);
+ return read_lvalue(gb, a);
+}
+
+static value_t bool_and(value_t a, value_t b) {return VALUE_16(a.value && b.value);}
+static value_t bool_or(value_t a, value_t b) {return VALUE_16(a.value || b.value);}
+static value_t equals(value_t a, value_t b) {return VALUE_16(a.value == b.value);}
+static value_t different(value_t a, value_t b) {return VALUE_16(a.value != b.value);}
+static value_t lower(value_t a, value_t b) {return VALUE_16(a.value < b.value);}
+static value_t greater(value_t a, value_t b) {return VALUE_16(a.value > b.value);}
+static value_t lower_equals(value_t a, value_t b) {return VALUE_16(a.value <= b.value);}
+static value_t greater_equals(value_t a, value_t b) {return VALUE_16(a.value >= b.value);}
+static value_t bank(value_t a, value_t b) {return (value_t) {true, a.value, b.value};}
+
+
+static struct {
+ const char *string;
+ int8_t priority;
+ value_t (*operator)(value_t, value_t);
+ value_t (*lvalue_operator)(GB_gameboy_t *, lvalue_t, uint16_t);
+} operators[] =
+{
+ // Yes. This is not C-like. But it makes much more sense.
+ // Deal with it.
+ {"+", 0, add},
+ {"-", 0, sub},
+ {"||", 0, bool_or},
+ {"|", 0, or},
+ {"*", 1, mul},
+ {"/", 1, _div},
+ {"%", 1, mod},
+ {"&&", 1, bool_and},
+ {"&", 1, and},
+ {"^", 1, xor},
+ {"<<", 2, shleft},
+ {"<=", 3, lower_equals},
+ {"<", 3, lower},
+ {">>", 2, shright},
+ {">=", 3, greater_equals},
+ {">", 3, greater},
+ {"==", 3, equals},
+ {"=", -1, NULL, assign},
+ {"!=", 3, different},
+ {":", 4, bank},
+};
+
+value_t debugger_evaluate(GB_gameboy_t *gb, const char *string,
+ size_t length, bool *error,
+ uint16_t *watchpoint_address, uint8_t *watchpoint_new_value);
+
+static lvalue_t debugger_evaluate_lvalue(GB_gameboy_t *gb, const char *string,
+ size_t length, bool *error,
+ uint16_t *watchpoint_address, uint8_t *watchpoint_new_value)
+{
+ *error = false;
+ // Strip whitespace
+ while (length && (string[0] == ' ' || string[0] == '\n' || string[0] == '\r' || string[0] == '\t')) {
+ string++;
+ length--;
+ }
+ while (length && (string[length-1] == ' ' || string[length-1] == '\n' || string[length-1] == '\r' || string[length-1] == '\t')) {
+ length--;
+ }
+ if (length == 0) {
+ GB_log(gb, "Expected expression.\n");
+ *error = true;
+ return (lvalue_t){0,};
+ }
+ if (string[0] == '(' && string[length - 1] == ')') {
+ // Attempt to strip parentheses
+ signed depth = 0;
+ for (unsigned i = 0; i < length; i++) {
+ if (string[i] == '(') depth++;
+ if (depth == 0) {
+ // First and last are not matching
+ depth = 1;
+ break;
+ }
+ if (string[i] == ')') depth--;
+ }
+ if (depth == 0) return debugger_evaluate_lvalue(gb, string + 1, length - 2, error, watchpoint_address, watchpoint_new_value);
+ }
+ else if (string[0] == '[' && string[length - 1] == ']') {
+ // Attempt to strip square parentheses (memory dereference)
+ signed depth = 0;
+ for (unsigned i = 0; i < length; i++) {
+ if (string[i] == '[') depth++;
+ if (depth == 0) {
+ // First and last are not matching
+ depth = 1;
+ break;
+ }
+ if (string[i] == ']') depth--;
+ }
+ if (depth == 0) {
+ return (lvalue_t){LVALUE_MEMORY, .memory_address = debugger_evaluate(gb, string + 1, length - 2, error, watchpoint_address, watchpoint_new_value)};
+ }
+ }
+ else if (string[0] == '{' && string[length - 1] == '}') {
+ // Attempt to strip curly parentheses (memory dereference)
+ signed depth = 0;
+ for (unsigned i = 0; i < length; i++) {
+ if (string[i] == '{') depth++;
+ if (depth == 0) {
+ // First and last are not matching
+ depth = 1;
+ break;
+ }
+ if (string[i] == '}') depth--;
+ }
+ if (depth == 0) {
+ return (lvalue_t){LVALUE_MEMORY16, .memory_address = debugger_evaluate(gb, string + 1, length - 2, error, watchpoint_address, watchpoint_new_value)};
+ }
+ }
+
+ // Registers
+ if (string[0] != '$' && (string[0] < '0' || string[0] > '9')) {
+ if (length == 1) {
+ switch (string[0]) {
+ case 'a': return (lvalue_t){LVALUE_REG_H, .register_address = &gb->registers[GB_REGISTER_AF]};
+ case 'f': return (lvalue_t){LVALUE_REG_L, .register_address = &gb->registers[GB_REGISTER_AF]};
+ case 'b': return (lvalue_t){LVALUE_REG_H, .register_address = &gb->registers[GB_REGISTER_BC]};
+ case 'c': return (lvalue_t){LVALUE_REG_L, .register_address = &gb->registers[GB_REGISTER_BC]};
+ case 'd': return (lvalue_t){LVALUE_REG_H, .register_address = &gb->registers[GB_REGISTER_DE]};
+ case 'e': return (lvalue_t){LVALUE_REG_L, .register_address = &gb->registers[GB_REGISTER_DE]};
+ case 'h': return (lvalue_t){LVALUE_REG_H, .register_address = &gb->registers[GB_REGISTER_HL]};
+ case 'l': return (lvalue_t){LVALUE_REG_L, .register_address = &gb->registers[GB_REGISTER_HL]};
+ }
+ }
+ else if (length == 2) {
+ switch (string[0]) {
+ case 'a': if (string[1] == 'f') return (lvalue_t){LVALUE_REG16, .register_address = &gb->registers[GB_REGISTER_AF]};
+ case 'b': if (string[1] == 'c') return (lvalue_t){LVALUE_REG16, .register_address = &gb->registers[GB_REGISTER_BC]};
+ case 'd': if (string[1] == 'e') return (lvalue_t){LVALUE_REG16, .register_address = &gb->registers[GB_REGISTER_DE]};
+ case 'h': if (string[1] == 'l') return (lvalue_t){LVALUE_REG16, .register_address = &gb->registers[GB_REGISTER_HL]};
+ case 's': if (string[1] == 'p') return (lvalue_t){LVALUE_REG16, .register_address = &gb->registers[GB_REGISTER_SP]};
+ case 'p': if (string[1] == 'c') return (lvalue_t){LVALUE_REG16, .register_address = &gb->pc};
+ }
+ }
+ GB_log(gb, "Unknown register: %.*s\n", (unsigned) length, string);
+ *error = true;
+ return (lvalue_t){0,};
+ }
+
+ GB_log(gb, "Expression is not an lvalue: %.*s\n", (unsigned) length, string);
+ *error = true;
+ return (lvalue_t){0,};
+}
+
+#define ERROR ((value_t){0,})
+value_t debugger_evaluate(GB_gameboy_t *gb, const char *string,
+ size_t length, bool *error,
+ uint16_t *watchpoint_address, uint8_t *watchpoint_new_value)
+{
+ /* Disable watchpoints while evaulating expressions */
+ uint16_t n_watchpoints = gb->n_watchpoints;
+ gb->n_watchpoints = 0;
+
+ value_t ret = ERROR;
+
+ *error = false;
+ // Strip whitespace
+ while (length && (string[0] == ' ' || string[0] == '\n' || string[0] == '\r' || string[0] == '\t')) {
+ string++;
+ length--;
+ }
+ while (length && (string[length-1] == ' ' || string[length-1] == '\n' || string[length-1] == '\r' || string[length-1] == '\t')) {
+ length--;
+ }
+ if (length == 0) {
+ GB_log(gb, "Expected expression.\n");
+ *error = true;
+ goto exit;
+ }
+ if (string[0] == '(' && string[length - 1] == ')') {
+ // Attempt to strip parentheses
+ signed depth = 0;
+ for (unsigned i = 0; i < length; i++) {
+ if (string[i] == '(') depth++;
+ if (depth == 0) {
+ // First and last are not matching
+ depth = 1;
+ break;
+ }
+ if (string[i] == ')') depth--;
+ }
+ if (depth == 0) {
+ ret = debugger_evaluate(gb, string + 1, length - 2, error, watchpoint_address, watchpoint_new_value);
+ goto exit;
+ }
+ }
+ else if (string[0] == '[' && string[length - 1] == ']') {
+ // Attempt to strip square parentheses (memory dereference)
+ signed depth = 0;
+ for (unsigned i = 0; i < length; i++) {
+ if (string[i] == '[') depth++;
+ if (depth == 0) {
+ // First and last are not matching
+ depth = 1;
+ break;
+ }
+ if (string[i] == ']') depth--;
+ }
+
+ if (depth == 0) {
+ value_t addr = debugger_evaluate(gb, string + 1, length - 2, error, watchpoint_address, watchpoint_new_value);
+ banking_state_t state;
+ if (addr.bank) {
+ save_banking_state(gb, &state);
+ switch_banking_state(gb, addr.bank);
+ }
+ ret = VALUE_16(GB_read_memory(gb, addr.value));
+ if (addr.bank) {
+ restore_banking_state(gb, &state);
+ }
+ goto exit;
+ }
+ }
+ else if (string[0] == '{' && string[length - 1] == '}') {
+ // Attempt to strip curly parentheses (memory dereference)
+ signed depth = 0;
+ for (unsigned i = 0; i < length; i++) {
+ if (string[i] == '{') depth++;
+ if (depth == 0) {
+ // First and last are not matching
+ depth = 1;
+ break;
+ }
+ if (string[i] == '}') depth--;
+ }
+
+ if (depth == 0) {
+ value_t addr = debugger_evaluate(gb, string + 1, length - 2, error, watchpoint_address, watchpoint_new_value);
+ banking_state_t state;
+ if (addr.bank) {
+ save_banking_state(gb, &state);
+ switch_banking_state(gb, addr.bank);
+ }
+ ret = VALUE_16(GB_read_memory(gb, addr.value) | (GB_read_memory(gb, addr.value + 1) * 0x100));
+ if (addr.bank) {
+ restore_banking_state(gb, &state);
+ }
+ goto exit;
+ }
+ }
+ // Search for lowest priority operator
+ signed depth = 0;
+ unsigned operator_index = -1;
+ unsigned operator_pos = 0;
+ for (unsigned i = 0; i < length; i++) {
+ if (string[i] == '(') depth++;
+ else if (string[i] == ')') depth--;
+ else if (string[i] == '[') depth++;
+ else if (string[i] == ']') depth--;
+ else if (depth == 0) {
+ for (unsigned j = 0; j < sizeof(operators) / sizeof(operators[0]); j++) {
+ unsigned operator_length = strlen(operators[j].string);
+ if (operator_length > length - i) continue; // Operator too long
+
+ if (memcmp(string + i, operators[j].string, operator_length) == 0) {
+ if (operator_index != -1 && operators[operator_index].priority < operators[j].priority) {
+ /* for supporting = vs ==, etc*/
+ i += operator_length - 1;
+ break;
+ }
+ // Found an operator!
+ operator_pos = i;
+ operator_index = j;
+ /* for supporting = vs ==, etc*/
+ i += operator_length - 1;
+ break;
+ }
+ }
+ }
+ }
+ if (operator_index != -1) {
+ unsigned right_start = (unsigned)(operator_pos + strlen(operators[operator_index].string));
+ value_t right = debugger_evaluate(gb, string + right_start, length - right_start, error, watchpoint_address, watchpoint_new_value);
+ if (*error) goto exit;
+ if (operators[operator_index].lvalue_operator) {
+ lvalue_t left = debugger_evaluate_lvalue(gb, string, operator_pos, error, watchpoint_address, watchpoint_new_value);
+ if (*error) goto exit;
+ ret = operators[operator_index].lvalue_operator(gb, left, right.value);
+ goto exit;
+ }
+ value_t left = debugger_evaluate(gb, string, operator_pos, error, watchpoint_address, watchpoint_new_value);
+ if (*error) goto exit;
+ ret = operators[operator_index].operator(left, right);
+ goto exit;
+ }
+
+ // Not an expression - must be a register or a literal
+
+ // Registers
+ if (string[0] != '$' && (string[0] < '0' || string[0] > '9')) {
+ if (length == 1) {
+ switch (string[0]) {
+ case 'a': ret = VALUE_16(gb->registers[GB_REGISTER_AF] >> 8); goto exit;
+ case 'f': ret = VALUE_16(gb->registers[GB_REGISTER_AF] & 0xFF); goto exit;
+ case 'b': ret = VALUE_16(gb->registers[GB_REGISTER_BC] >> 8); goto exit;
+ case 'c': ret = VALUE_16(gb->registers[GB_REGISTER_BC] & 0xFF); goto exit;
+ case 'd': ret = VALUE_16(gb->registers[GB_REGISTER_DE] >> 8); goto exit;
+ case 'e': ret = VALUE_16(gb->registers[GB_REGISTER_DE] & 0xFF); goto exit;
+ case 'h': ret = VALUE_16(gb->registers[GB_REGISTER_HL] >> 8); goto exit;
+ case 'l': ret = VALUE_16(gb->registers[GB_REGISTER_HL] & 0xFF); goto exit;
+ }
+ }
+ else if (length == 2) {
+ switch (string[0]) {
+ case 'a': if (string[1] == 'f') {ret = VALUE_16(gb->registers[GB_REGISTER_AF]); goto exit;}
+ case 'b': if (string[1] == 'c') {ret = VALUE_16(gb->registers[GB_REGISTER_BC]); goto exit;}
+ case 'd': if (string[1] == 'e') {ret = VALUE_16(gb->registers[GB_REGISTER_DE]); goto exit;}
+ case 'h': if (string[1] == 'l') {ret = VALUE_16(gb->registers[GB_REGISTER_HL]); goto exit;}
+ case 's': if (string[1] == 'p') {ret = VALUE_16(gb->registers[GB_REGISTER_SP]); goto exit;}
+ case 'p': if (string[1] == 'c') {ret = (value_t){true, bank_for_addr(gb, gb->pc), gb->pc}; goto exit;}
+ }
+ }
+ else if (length == 3) {
+ if (watchpoint_address && memcmp(string, "old", 3) == 0) {
+ ret = VALUE_16(GB_read_memory(gb, *watchpoint_address));
+ goto exit;
+ }
+
+ if (watchpoint_new_value && memcmp(string, "new", 3) == 0) {
+ ret = VALUE_16(*watchpoint_new_value);
+ goto exit;
+ }
+
+ /* $new is identical to $old in read conditions */
+ if (watchpoint_address && memcmp(string, "new", 3) == 0) {
+ ret = VALUE_16(GB_read_memory(gb, *watchpoint_address));
+ goto exit;
+ }
+ }
+
+ char symbol_name[length + 1];
+ memcpy(symbol_name, string, length);
+ symbol_name[length] = 0;
+ const GB_symbol_t *symbol = GB_reversed_map_find_symbol(&gb->reversed_symbol_map, symbol_name);
+ if (symbol) {
+ ret = (value_t){true, symbol->bank, symbol->addr};
+ goto exit;
+ }
+
+ GB_log(gb, "Unknown register or symbol: %.*s\n", (unsigned) length, string);
+ *error = true;
+ goto exit;
+ }
+
+ char *end;
+ unsigned base = 10;
+ if (string[0] == '$') {
+ string++;
+ base = 16;
+ length--;
+ }
+ uint16_t literal = (uint16_t) (strtol(string, &end, base));
+ if (end != string + length) {
+ GB_log(gb, "Failed to parse: %.*s\n", (unsigned) length, string);
+ *error = true;
+ goto exit;
+ }
+ ret = VALUE_16(literal);
+exit:
+ gb->n_watchpoints = n_watchpoints;
+ return ret;
+}
+
+struct debugger_command_s;
+typedef bool debugger_command_imp_t(GB_gameboy_t *gb, char *arguments, char *modifiers, const struct debugger_command_s *command);
+typedef char *debugger_completer_imp_t(GB_gameboy_t *gb, const char *string, uintptr_t *context);
+
+typedef struct debugger_command_s {
+ const char *command;
+ uint8_t min_length;
+ debugger_command_imp_t *implementation;
+ const char *help_string; // Null if should not appear in help
+ const char *arguments_format; // For usage message
+ const char *modifiers_format; // For usage message
+ debugger_completer_imp_t *argument_completer;
+ debugger_completer_imp_t *modifiers_completer;
+} debugger_command_t;
+
+static const char *lstrip(const char *str)
+{
+ while (*str == ' ' || *str == '\t') {
+ str++;
+ }
+ return str;
+}
+
+#define STOPPED_ONLY \
+if (!gb->debug_stopped) { \
+GB_log(gb, "Program is running. \n"); \
+return false; \
+}
+
+#define NO_MODIFIERS \
+if (modifiers) { \
+print_usage(gb, command); \
+return true; \
+}
+
+static void print_usage(GB_gameboy_t *gb, const debugger_command_t *command)
+{
+ GB_log(gb, "Usage: %s", command->command);
+
+ if (command->modifiers_format) {
+ GB_log(gb, "[/%s]", command->modifiers_format);
+ }
+
+ if (command->arguments_format) {
+ GB_log(gb, " %s", command->arguments_format);
+ }
+
+ GB_log(gb, "\n");
+}
+
+static bool cont(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ STOPPED_ONLY
+
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ gb->debug_stopped = false;
+ return false;
+}
+
+static bool next(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ STOPPED_ONLY
+
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ gb->debug_stopped = false;
+ gb->debug_next_command = true;
+ gb->debug_call_depth = 0;
+ return false;
+}
+
+static bool step(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ STOPPED_ONLY
+
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ return false;
+}
+
+static bool finish(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ STOPPED_ONLY
+
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ gb->debug_stopped = false;
+ gb->debug_fin_command = true;
+ gb->debug_call_depth = 0;
+ return false;
+}
+
+static bool stack_leak_detection(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ STOPPED_ONLY
+
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ gb->debug_stopped = false;
+ gb->stack_leak_detection = true;
+ gb->debug_call_depth = 0;
+ return false;
+}
+
+static bool registers(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+
+ GB_log(gb, "AF = $%04x (%c%c%c%c)\n", gb->registers[GB_REGISTER_AF], /* AF can't really be an address */
+ (gb->f & GB_CARRY_FLAG)? 'C' : '-',
+ (gb->f & GB_HALF_CARRY_FLAG)? 'H' : '-',
+ (gb->f & GB_SUBTRACT_FLAG)? 'N' : '-',
+ (gb->f & GB_ZERO_FLAG)? 'Z' : '-');
+ GB_log(gb, "BC = %s\n", value_to_string(gb, gb->registers[GB_REGISTER_BC], false));
+ GB_log(gb, "DE = %s\n", value_to_string(gb, gb->registers[GB_REGISTER_DE], false));
+ GB_log(gb, "HL = %s\n", value_to_string(gb, gb->registers[GB_REGISTER_HL], false));
+ GB_log(gb, "SP = %s\n", value_to_string(gb, gb->registers[GB_REGISTER_SP], false));
+ GB_log(gb, "PC = %s\n", value_to_string(gb, gb->pc, false));
+ GB_log(gb, "IME = %s\n", gb->ime? "Enabled" : "Disabled");
+ return true;
+}
+
+static char *on_off_completer(GB_gameboy_t *gb, const char *string, uintptr_t *context)
+{
+ size_t length = strlen(string);
+ const char *suggestions[] = {"on", "off"};
+ while (*context < sizeof(suggestions) / sizeof(suggestions[0])) {
+ if (memcmp(string, suggestions[*context], length) == 0) {
+ return strdup(suggestions[(*context)++] + length);
+ }
+ (*context)++;
+ }
+ return NULL;
+}
+
+/* Enable or disable software breakpoints */
+static bool softbreak(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ if (strcmp(lstrip(arguments), "on") == 0 || !strlen(lstrip(arguments))) {
+ gb->has_software_breakpoints = true;
+ }
+ else if (strcmp(lstrip(arguments), "off") == 0) {
+ gb->has_software_breakpoints = false;
+ }
+ else {
+ print_usage(gb, command);
+ }
+
+ return true;
+}
+
+/* Find the index of the closest breakpoint equal or greater to addr */
+static uint16_t find_breakpoint(GB_gameboy_t *gb, value_t addr)
+{
+ if (!gb->breakpoints) {
+ return 0;
+ }
+
+ uint32_t key = BP_KEY(addr);
+
+ unsigned min = 0;
+ unsigned max = gb->n_breakpoints;
+ while (min < max) {
+ uint16_t pivot = (min + max) / 2;
+ if (gb->breakpoints[pivot].key == key) return pivot;
+ if (gb->breakpoints[pivot].key > key) {
+ max = pivot;
+ }
+ else {
+ min = pivot + 1;
+ }
+ }
+ return (uint16_t) min;
+}
+
+static inline bool is_legal_symbol_char(char c)
+{
+ if (c >= '0' && c <= '9') return true;
+ if (c >= 'A' && c <= 'Z') return true;
+ if (c >= 'a' && c <= 'z') return true;
+ if (c == '_') return true;
+ if (c == '.') return true;
+ return false;
+}
+
+static char *symbol_completer(GB_gameboy_t *gb, const char *string, uintptr_t *_context)
+{
+ const char *symbol_prefix = string;
+ while (*string) {
+ if (!is_legal_symbol_char(*string)) {
+ symbol_prefix = string + 1;
+ }
+ string++;
+ }
+
+ if (*symbol_prefix == '$') {
+ return NULL;
+ }
+
+ struct {
+ uint16_t bank;
+ uint32_t symbol;
+ } *context = (void *)_context;
+
+
+ size_t length = strlen(symbol_prefix);
+ while (context->bank < 0x200) {
+ if (gb->bank_symbols[context->bank] == NULL ||
+ context->symbol >= gb->bank_symbols[context->bank]->n_symbols) {
+ context->bank++;
+ context->symbol = 0;
+ continue;
+ }
+ const char *candidate = gb->bank_symbols[context->bank]->symbols[context->symbol++].name;
+ if (memcmp(symbol_prefix, candidate, length) == 0) {
+ return strdup(candidate + length);
+ }
+ }
+ return NULL;
+}
+
+static char *j_completer(GB_gameboy_t *gb, const char *string, uintptr_t *context)
+{
+ size_t length = strlen(string);
+ const char *suggestions[] = {"j"};
+ while (*context < sizeof(suggestions) / sizeof(suggestions[0])) {
+ if (memcmp(string, suggestions[*context], length) == 0) {
+ return strdup(suggestions[(*context)++] + length);
+ }
+ (*context)++;
+ }
+ return NULL;
+}
+
+static bool breakpoint(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ bool is_jump_to = true;
+ if (!modifiers) {
+ is_jump_to = false;
+ }
+ else if (strcmp(modifiers, "j") != 0) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ if (strlen(lstrip(arguments)) == 0) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ if (gb->n_breakpoints == (typeof(gb->n_breakpoints)) -1) {
+ GB_log(gb, "Too many breakpoints set\n");
+ return true;
+ }
+
+ char *condition = NULL;
+ if ((condition = strstr(arguments, " if "))) {
+ *condition = 0;
+ condition += strlen(" if ");
+ /* Verify condition is sane (Todo: This might have side effects!) */
+ bool error;
+ debugger_evaluate(gb, condition, (unsigned)strlen(condition), &error, NULL, NULL);
+ if (error) return true;
+
+ }
+
+ bool error;
+ value_t result = debugger_evaluate(gb, arguments, (unsigned)strlen(arguments), &error, NULL, NULL);
+ uint32_t key = BP_KEY(result);
+
+ if (error) return true;
+
+ uint16_t index = find_breakpoint(gb, result);
+ if (index < gb->n_breakpoints && gb->breakpoints[index].key == key) {
+ GB_log(gb, "Breakpoint already set at %s\n", debugger_value_to_string(gb, result, true));
+ if (!gb->breakpoints[index].condition && condition) {
+ GB_log(gb, "Added condition to breakpoint\n");
+ gb->breakpoints[index].condition = strdup(condition);
+ }
+ else if (gb->breakpoints[index].condition && condition) {
+ GB_log(gb, "Replaced breakpoint condition\n");
+ free(gb->breakpoints[index].condition);
+ gb->breakpoints[index].condition = strdup(condition);
+ }
+ else if (gb->breakpoints[index].condition && !condition) {
+ GB_log(gb, "Removed breakpoint condition\n");
+ free(gb->breakpoints[index].condition);
+ gb->breakpoints[index].condition = NULL;
+ }
+ return true;
+ }
+
+ gb->breakpoints = realloc(gb->breakpoints, (gb->n_breakpoints + 1) * sizeof(gb->breakpoints[0]));
+ memmove(&gb->breakpoints[index + 1], &gb->breakpoints[index], (gb->n_breakpoints - index) * sizeof(gb->breakpoints[0]));
+ gb->breakpoints[index].key = key;
+
+ if (condition) {
+ gb->breakpoints[index].condition = strdup(condition);
+ }
+ else {
+ gb->breakpoints[index].condition = NULL;
+ }
+ gb->n_breakpoints++;
+
+ gb->breakpoints[index].is_jump_to = is_jump_to;
+
+ if (is_jump_to) {
+ gb->has_jump_to_breakpoints = true;
+ }
+
+ GB_log(gb, "Breakpoint set at %s\n", debugger_value_to_string(gb, result, true));
+ return true;
+}
+
+static bool delete(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ if (strlen(lstrip(arguments)) == 0) {
+ for (unsigned i = gb->n_breakpoints; i--;) {
+ if (gb->breakpoints[i].condition) {
+ free(gb->breakpoints[i].condition);
+ }
+ }
+ free(gb->breakpoints);
+ gb->breakpoints = NULL;
+ gb->n_breakpoints = 0;
+ return true;
+ }
+
+ bool error;
+ value_t result = debugger_evaluate(gb, arguments, (unsigned)strlen(arguments), &error, NULL, NULL);
+ uint32_t key = BP_KEY(result);
+
+ if (error) return true;
+
+ uint16_t index = 0;
+ for (unsigned i = 0; i < gb->n_breakpoints; i++) {
+ if (gb->breakpoints[i].key == key) {
+ /* Full match */
+ index = i;
+ break;
+ }
+ if (gb->breakpoints[i].addr == result.value && result.has_bank != (gb->breakpoints[i].bank != (uint16_t) -1)) {
+ /* Partial match */
+ index = i;
+ }
+ }
+
+ if (index >= gb->n_breakpoints) {
+ GB_log(gb, "No breakpoint set at %s\n", debugger_value_to_string(gb, result, true));
+ return true;
+ }
+
+ result.bank = gb->breakpoints[index].bank;
+ result.has_bank = gb->breakpoints[index].bank != (uint16_t) -1;
+
+ if (gb->breakpoints[index].condition) {
+ free(gb->breakpoints[index].condition);
+ }
+
+ if (gb->breakpoints[index].is_jump_to) {
+ gb->has_jump_to_breakpoints = false;
+ for (unsigned i = 0; i < gb->n_breakpoints; i++) {
+ if (i == index) continue;
+ if (gb->breakpoints[i].is_jump_to) {
+ gb->has_jump_to_breakpoints = true;
+ break;
+ }
+ }
+ }
+
+ memmove(&gb->breakpoints[index], &gb->breakpoints[index + 1], (gb->n_breakpoints - index - 1) * sizeof(gb->breakpoints[0]));
+ gb->n_breakpoints--;
+ gb->breakpoints = realloc(gb->breakpoints, gb->n_breakpoints * sizeof(gb->breakpoints[0]));
+
+ GB_log(gb, "Breakpoint removed from %s\n", debugger_value_to_string(gb, result, true));
+ return true;
+}
+
+/* Find the index of the closest watchpoint equal or greater to addr */
+static uint16_t find_watchpoint(GB_gameboy_t *gb, value_t addr)
+{
+ if (!gb->watchpoints) {
+ return 0;
+ }
+ uint32_t key = WP_KEY(addr);
+ unsigned min = 0;
+ unsigned max = gb->n_watchpoints;
+ while (min < max) {
+ uint16_t pivot = (min + max) / 2;
+ if (gb->watchpoints[pivot].key == key) return pivot;
+ if (gb->watchpoints[pivot].key > key) {
+ max = pivot;
+ }
+ else {
+ min = pivot + 1;
+ }
+ }
+ return (uint16_t) min;
+}
+
+static char *rw_completer(GB_gameboy_t *gb, const char *string, uintptr_t *context)
+{
+ size_t length = strlen(string);
+ const char *suggestions[] = {"r", "rw", "w"};
+ while (*context < sizeof(suggestions) / sizeof(suggestions[0])) {
+ if (memcmp(string, suggestions[*context], length) == 0) {
+ return strdup(suggestions[(*context)++] + length);
+ }
+ (*context)++;
+ }
+ return NULL;
+}
+
+static bool watch(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ if (strlen(lstrip(arguments)) == 0) {
+print_usage:
+ print_usage(gb, command);
+ return true;
+ }
+
+ if (gb->n_watchpoints == (typeof(gb->n_watchpoints)) -1) {
+ GB_log(gb, "Too many watchpoints set\n");
+ return true;
+ }
+
+ if (!modifiers) {
+ modifiers = "w";
+ }
+
+ uint8_t flags = 0;
+ while (*modifiers) {
+ switch (*modifiers) {
+ case 'r':
+ flags |= GB_WATCHPOINT_R;
+ break;
+ case 'w':
+ flags |= GB_WATCHPOINT_W;
+ break;
+ default:
+ goto print_usage;
+ }
+ modifiers++;
+ }
+
+ if (!flags) {
+ goto print_usage;
+ }
+
+ char *condition = NULL;
+ if ((condition = strstr(arguments, " if "))) {
+ *condition = 0;
+ condition += strlen(" if ");
+ /* Verify condition is sane (Todo: This might have side effects!) */
+ bool error;
+ /* To make $new and $old legal */
+ uint16_t dummy = 0;
+ uint8_t dummy2 = 0;
+ debugger_evaluate(gb, condition, (unsigned)strlen(condition), &error, &dummy, &dummy2);
+ if (error) return true;
+
+ }
+
+ bool error;
+ value_t result = debugger_evaluate(gb, arguments, (unsigned)strlen(arguments), &error, NULL, NULL);
+ uint32_t key = WP_KEY(result);
+
+ if (error) return true;
+
+ uint16_t index = find_watchpoint(gb, result);
+ if (index < gb->n_watchpoints && gb->watchpoints[index].key == key) {
+ GB_log(gb, "Watchpoint already set at %s\n", debugger_value_to_string(gb, result, true));
+ if (gb->watchpoints[index].flags != flags) {
+ GB_log(gb, "Modified watchpoint type\n");
+ gb->watchpoints[index].flags = flags;
+ }
+ if (!gb->watchpoints[index].condition && condition) {
+ GB_log(gb, "Added condition to watchpoint\n");
+ gb->watchpoints[index].condition = strdup(condition);
+ }
+ else if (gb->watchpoints[index].condition && condition) {
+ GB_log(gb, "Replaced watchpoint condition\n");
+ free(gb->watchpoints[index].condition);
+ gb->watchpoints[index].condition = strdup(condition);
+ }
+ else if (gb->watchpoints[index].condition && !condition) {
+ GB_log(gb, "Removed watchpoint condition\n");
+ free(gb->watchpoints[index].condition);
+ gb->watchpoints[index].condition = NULL;
+ }
+ return true;
+ }
+
+ gb->watchpoints = realloc(gb->watchpoints, (gb->n_watchpoints + 1) * sizeof(gb->watchpoints[0]));
+ memmove(&gb->watchpoints[index + 1], &gb->watchpoints[index], (gb->n_watchpoints - index) * sizeof(gb->watchpoints[0]));
+ gb->watchpoints[index].key = key;
+ gb->watchpoints[index].flags = flags;
+ if (condition) {
+ gb->watchpoints[index].condition = strdup(condition);
+ }
+ else {
+ gb->watchpoints[index].condition = NULL;
+ }
+ gb->n_watchpoints++;
+
+ GB_log(gb, "Watchpoint set at %s\n", debugger_value_to_string(gb, result, true));
+ return true;
+}
+
+static bool unwatch(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ if (strlen(lstrip(arguments)) == 0) {
+ for (unsigned i = gb->n_watchpoints; i--;) {
+ if (gb->watchpoints[i].condition) {
+ free(gb->watchpoints[i].condition);
+ }
+ }
+ free(gb->watchpoints);
+ gb->watchpoints = NULL;
+ gb->n_watchpoints = 0;
+ return true;
+ }
+
+ bool error;
+ value_t result = debugger_evaluate(gb, arguments, (unsigned)strlen(arguments), &error, NULL, NULL);
+ uint32_t key = WP_KEY(result);
+
+ if (error) return true;
+
+ uint16_t index = 0;
+ for (unsigned i = 0; i < gb->n_watchpoints; i++) {
+ if (gb->watchpoints[i].key == key) {
+ /* Full match */
+ index = i;
+ break;
+ }
+ if (gb->watchpoints[i].addr == result.value && result.has_bank != (gb->watchpoints[i].bank != (uint16_t) -1)) {
+ /* Partial match */
+ index = i;
+ }
+ }
+
+ if (index >= gb->n_watchpoints) {
+ GB_log(gb, "No watchpoint set at %s\n", debugger_value_to_string(gb, result, true));
+ return true;
+ }
+
+ result.bank = gb->watchpoints[index].bank;
+ result.has_bank = gb->watchpoints[index].bank != (uint16_t) -1;
+
+ if (gb->watchpoints[index].condition) {
+ free(gb->watchpoints[index].condition);
+ }
+
+ memmove(&gb->watchpoints[index], &gb->watchpoints[index + 1], (gb->n_watchpoints - index - 1) * sizeof(gb->watchpoints[0]));
+ gb->n_watchpoints--;
+ gb->watchpoints = realloc(gb->watchpoints, gb->n_watchpoints *sizeof(gb->watchpoints[0]));
+
+ GB_log(gb, "Watchpoint removed from %s\n", debugger_value_to_string(gb, result, true));
+ return true;
+}
+
+static bool list(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ if (gb->n_breakpoints == 0) {
+ GB_log(gb, "No breakpoints set.\n");
+ }
+ else {
+ GB_log(gb, "%d breakpoint(s) set:\n", gb->n_breakpoints);
+ for (uint16_t i = 0; i < gb->n_breakpoints; i++) {
+ value_t addr = (value_t){gb->breakpoints[i].bank != (uint16_t)-1, gb->breakpoints[i].bank, gb->breakpoints[i].addr};
+ if (gb->breakpoints[i].condition) {
+ GB_log(gb, " %d. %s (%sCondition: %s)\n", i + 1,
+ debugger_value_to_string(gb, addr, addr.has_bank),
+ gb->breakpoints[i].is_jump_to? "Jump to, ": "",
+ gb->breakpoints[i].condition);
+ }
+ else {
+ GB_log(gb, " %d. %s%s\n", i + 1,
+ debugger_value_to_string(gb, addr, addr.has_bank),
+ gb->breakpoints[i].is_jump_to? " (Jump to)" : "");
+ }
+ }
+ }
+
+ if (gb->n_watchpoints == 0) {
+ GB_log(gb, "No watchpoints set.\n");
+ }
+ else {
+ GB_log(gb, "%d watchpoint(s) set:\n", gb->n_watchpoints);
+ for (uint16_t i = 0; i < gb->n_watchpoints; i++) {
+ value_t addr = (value_t){gb->watchpoints[i].bank != (uint16_t)-1, gb->watchpoints[i].bank, gb->watchpoints[i].addr};
+ if (gb->watchpoints[i].condition) {
+ GB_log(gb, " %d. %s (%c%c, Condition: %s)\n", i + 1, debugger_value_to_string(gb, addr, addr.has_bank),
+ (gb->watchpoints[i].flags & GB_WATCHPOINT_R)? 'r' : '-',
+ (gb->watchpoints[i].flags & GB_WATCHPOINT_W)? 'w' : '-',
+ gb->watchpoints[i].condition);
+ }
+ else {
+ GB_log(gb, " %d. %s (%c%c)\n", i + 1, debugger_value_to_string(gb, addr, addr.has_bank),
+ (gb->watchpoints[i].flags & GB_WATCHPOINT_R)? 'r' : '-',
+ (gb->watchpoints[i].flags & GB_WATCHPOINT_W)? 'w' : '-');
+ }
+ }
+ }
+
+ return true;
+}
+
+static bool _should_break(GB_gameboy_t *gb, value_t addr, bool jump_to)
+{
+ uint16_t index = find_breakpoint(gb, addr);
+ uint32_t key = BP_KEY(addr);
+
+ if (index < gb->n_breakpoints && gb->breakpoints[index].key == key && gb->breakpoints[index].is_jump_to == jump_to) {
+ if (!gb->breakpoints[index].condition) {
+ return true;
+ }
+ bool error;
+ bool condition = debugger_evaluate(gb, gb->breakpoints[index].condition,
+ (unsigned)strlen(gb->breakpoints[index].condition), &error, NULL, NULL).value;
+ if (error) {
+ /* Should never happen */
+ GB_log(gb, "An internal error has occured\n");
+ return true;
+ }
+ return condition;
+ }
+ return false;
+}
+
+static bool should_break(GB_gameboy_t *gb, uint16_t addr, bool jump_to)
+{
+ /* Try any-bank breakpoint */
+ value_t full_addr = (VALUE_16(addr));
+ if (_should_break(gb, full_addr, jump_to)) return true;
+
+ /* Try bank-specific breakpoint */
+ full_addr.has_bank = true;
+ full_addr.bank = bank_for_addr(gb, addr);
+ return _should_break(gb, full_addr, jump_to);
+}
+
+static char *format_completer(GB_gameboy_t *gb, const char *string, uintptr_t *context)
+{
+ size_t length = strlen(string);
+ const char *suggestions[] = {"a", "b", "d", "o", "x"};
+ while (*context < sizeof(suggestions) / sizeof(suggestions[0])) {
+ if (memcmp(string, suggestions[*context], length) == 0) {
+ return strdup(suggestions[(*context)++] + length);
+ }
+ (*context)++;
+ }
+ return NULL;
+}
+
+static bool print(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ if (strlen(lstrip(arguments)) == 0) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ if (!modifiers || !modifiers[0]) {
+ modifiers = "a";
+ }
+ else if (modifiers[1]) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ bool error;
+ value_t result = debugger_evaluate(gb, arguments, (unsigned)strlen(arguments), &error, NULL, NULL);
+ if (!error) {
+ switch (modifiers[0]) {
+ case 'a':
+ GB_log(gb, "=%s\n", debugger_value_to_string(gb, result, false));
+ break;
+ case 'd':
+ GB_log(gb, "=%d\n", result.value);
+ break;
+ case 'x':
+ GB_log(gb, "=$%x\n", result.value);
+ break;
+ case 'o':
+ GB_log(gb, "=0%o\n", result.value);
+ break;
+ case 'b':
+ {
+ if (!result.value) {
+ GB_log(gb, "=%%0\n");
+ break;
+ }
+ char binary[17];
+ binary[16] = 0;
+ char *ptr = &binary[16];
+ while (result.value) {
+ *(--ptr) = (result.value & 1)? '1' : '0';
+ result.value >>= 1;
+ }
+ GB_log(gb, "=%%%s\n", ptr);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ return true;
+}
+
+static bool examine(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ if (strlen(lstrip(arguments)) == 0) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ bool error;
+ value_t addr = debugger_evaluate(gb, arguments, (unsigned)strlen(arguments), &error, NULL, NULL);
+ uint16_t count = 32;
+
+ if (modifiers) {
+ char *end;
+ count = (uint16_t) (strtol(modifiers, &end, 10));
+ if (*end) {
+ print_usage(gb, command);
+ return true;
+ }
+ }
+
+ if (!error) {
+ if (addr.has_bank) {
+ banking_state_t old_state;
+ save_banking_state(gb, &old_state);
+ switch_banking_state(gb, addr.bank);
+
+ while (count) {
+ GB_log(gb, "%02x:%04x: ", addr.bank, addr.value);
+ for (unsigned i = 0; i < 16 && count; i++) {
+ GB_log(gb, "%02x ", GB_read_memory(gb, addr.value + i));
+ count--;
+ }
+ addr.value += 16;
+ GB_log(gb, "\n");
+ }
+
+ restore_banking_state(gb, &old_state);
+ }
+ else {
+ while (count) {
+ GB_log(gb, "%04x: ", addr.value);
+ for (unsigned i = 0; i < 16 && count; i++) {
+ GB_log(gb, "%02x ", GB_read_memory(gb, addr.value + i));
+ count--;
+ }
+ addr.value += 16;
+ GB_log(gb, "\n");
+ }
+ }
+ }
+ return true;
+}
+
+static bool disassemble(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ if (strlen(lstrip(arguments)) == 0) {
+ arguments = "pc";
+ }
+
+ bool error;
+ value_t addr = debugger_evaluate(gb, arguments, (unsigned)strlen(arguments), &error, NULL, NULL);
+ uint16_t count = 5;
+
+ if (modifiers) {
+ char *end;
+ count = (uint16_t) (strtol(modifiers, &end, 10));
+ if (*end) {
+ print_usage(gb, command);
+ return true;
+ }
+ }
+
+ if (!error) {
+ if (addr.has_bank) {
+ banking_state_t old_state;
+ save_banking_state(gb, &old_state);
+ switch_banking_state(gb, addr.bank);
+
+ GB_cpu_disassemble(gb, addr.value, count);
+
+ restore_banking_state(gb, &old_state);
+ }
+ else {
+ GB_cpu_disassemble(gb, addr.value, count);
+ }
+ }
+ return true;
+}
+
+static bool mbc(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ const GB_cartridge_t *cartridge = gb->cartridge_type;
+
+ if (cartridge->has_ram) {
+ GB_log(gb, "Cartridge includes%s RAM: $%x bytes\n", cartridge->has_battery? " battery-backed": "", gb->mbc_ram_size);
+ }
+ else {
+ GB_log(gb, "No cartridge RAM\n");
+ }
+
+ if (cartridge->mbc_type) {
+ if (gb->is_mbc30) {
+ GB_log(gb, "MBC30\n");
+ }
+ else {
+ static const char *const mapper_names[] = {
+ [GB_MBC1] = "MBC1",
+ [GB_MBC2] = "MBC2",
+ [GB_MBC3] = "MBC3",
+ [GB_MBC5] = "MBC5",
+ [GB_HUC1] = "HUC-1",
+ [GB_HUC3] = "HUC-3",
+ };
+ GB_log(gb, "%s\n", mapper_names[cartridge->mbc_type]);
+ }
+ GB_log(gb, "Current mapped ROM bank: %x\n", gb->mbc_rom_bank);
+ if (cartridge->has_ram) {
+ GB_log(gb, "Current mapped RAM bank: %x\n", gb->mbc_ram_bank);
+ if (gb->cartridge_type->mbc_type != GB_HUC1) {
+ GB_log(gb, "RAM is curently %s\n", gb->mbc_ram_enable? "enabled" : "disabled");
+ }
+ }
+ if (cartridge->mbc_type == GB_MBC1 && gb->mbc1_wiring == GB_STANDARD_MBC1_WIRING) {
+ GB_log(gb, "MBC1 banking mode is %s\n", gb->mbc1.mode == 1 ? "RAM" : "ROM");
+ }
+ if (cartridge->mbc_type == GB_MBC1 && gb->mbc1_wiring == GB_MBC1M_WIRING) {
+ GB_log(gb, "MBC1 uses MBC1M wiring. \n");
+ GB_log(gb, "Current mapped ROM0 bank: %x\n", gb->mbc_rom0_bank);
+ GB_log(gb, "MBC1 multicart banking mode is %s\n", gb->mbc1.mode == 1 ? "enabled" : "disabled");
+ }
+
+ }
+ else {
+ GB_log(gb, "No MBC\n");
+ }
+
+ if (cartridge->has_rumble) {
+ GB_log(gb, "Cart contains a Rumble Pak\n");
+ }
+
+ if (cartridge->has_rtc) {
+ GB_log(gb, "Cart contains a real time clock\n");
+ }
+
+ return true;
+}
+
+static bool backtrace(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ GB_log(gb, " 1. %s\n", debugger_value_to_string(gb, (value_t){true, bank_for_addr(gb, gb->pc), gb->pc}, true));
+ for (unsigned i = gb->backtrace_size; i--;) {
+ GB_log(gb, "%3d. %s\n", gb->backtrace_size - i + 1, debugger_value_to_string(gb, (value_t){true, gb->backtrace_returns[i].bank, gb->backtrace_returns[i].addr}, true));
+ }
+
+ return true;
+}
+
+static bool ticks(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ STOPPED_ONLY
+
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ GB_log(gb, "Ticks: %llu. (Resetting)\n", (unsigned long long)gb->debugger_ticks);
+ gb->debugger_ticks = 0;
+
+ return true;
+}
+
+
+static bool palettes(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ if (!GB_is_cgb(gb)) {
+ GB_log(gb, "Not available on a DMG.\n");
+ return true;
+ }
+
+ GB_log(gb, "Background palettes: \n");
+ for (unsigned i = 0; i < 32; i++) {
+ GB_log(gb, "%04x ", ((uint16_t *)&gb->background_palettes_data)[i]);
+ if (i % 4 == 3) {
+ GB_log(gb, "\n");
+ }
+ }
+
+ GB_log(gb, "Sprites palettes: \n");
+ for (unsigned i = 0; i < 32; i++) {
+ GB_log(gb, "%04x ", ((uint16_t *)&gb->sprite_palettes_data)[i]);
+ if (i % 4 == 3) {
+ GB_log(gb, "\n");
+ }
+ }
+
+ return true;
+}
+
+static bool lcd(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+ GB_log(gb, "LCDC:\n");
+ GB_log(gb, " LCD enabled: %s\n",(gb->io_registers[GB_IO_LCDC] & 128)? "Enabled" : "Disabled");
+ GB_log(gb, " %s: %s\n", (gb->cgb_mode? "Sprite priority flags" : "Background and Window"),
+ (gb->io_registers[GB_IO_LCDC] & 1)? "Enabled" : "Disabled");
+ GB_log(gb, " Objects: %s\n", (gb->io_registers[GB_IO_LCDC] & 2)? "Enabled" : "Disabled");
+ GB_log(gb, " Object size: %s\n", (gb->io_registers[GB_IO_LCDC] & 4)? "8x16" : "8x8");
+ GB_log(gb, " Background tilemap: %s\n", (gb->io_registers[GB_IO_LCDC] & 8)? "$9C00" : "$9800");
+ GB_log(gb, " Background and Window Tileset: %s\n", (gb->io_registers[GB_IO_LCDC] & 16)? "$8000" : "$8800");
+ GB_log(gb, " Window: %s\n", (gb->io_registers[GB_IO_LCDC] & 32)? "Enabled" : "Disabled");
+ GB_log(gb, " Window tilemap: %s\n", (gb->io_registers[GB_IO_LCDC] & 64)? "$9C00" : "$9800");
+
+ GB_log(gb, "\nSTAT:\n");
+ static const char *modes[] = {"Mode 0, H-Blank", "Mode 1, V-Blank", "Mode 2, OAM", "Mode 3, Rendering"};
+ GB_log(gb, " Current mode: %s\n", modes[gb->io_registers[GB_IO_STAT] & 3]);
+ GB_log(gb, " LYC flag: %s\n", (gb->io_registers[GB_IO_STAT] & 4)? "On" : "Off");
+ GB_log(gb, " H-Blank interrupt: %s\n", (gb->io_registers[GB_IO_STAT] & 8)? "Enabled" : "Disabled");
+ GB_log(gb, " V-Blank interrupt: %s\n", (gb->io_registers[GB_IO_STAT] & 16)? "Enabled" : "Disabled");
+ GB_log(gb, " OAM interrupt: %s\n", (gb->io_registers[GB_IO_STAT] & 32)? "Enabled" : "Disabled");
+ GB_log(gb, " LYC interrupt: %s\n", (gb->io_registers[GB_IO_STAT] & 64)? "Enabled" : "Disabled");
+
+
+
+ GB_log(gb, "\nCurrent line: %d\n", gb->current_line);
+ GB_log(gb, "Current state: ");
+ if (!(gb->io_registers[GB_IO_LCDC] & 0x80)) {
+ GB_log(gb, "Off\n");
+ }
+ else if (gb->display_state == 7 || gb->display_state == 8) {
+ GB_log(gb, "Reading OAM data (%d/40)\n", gb->display_state == 8? gb->oam_search_index : 0);
+ }
+ else if (gb->display_state <= 3 || gb->display_state == 24 || gb->display_state == 31) {
+ GB_log(gb, "Glitched line 0 OAM mode (%d cycles to next event)\n", -gb->display_cycles / 2);
+ }
+ else if (gb->mode_for_interrupt == 3) {
+ signed pixel = gb->position_in_line > 160? (int8_t) gb->position_in_line : gb->position_in_line;
+ GB_log(gb, "Rendering pixel (%d/160)\n", pixel);
+ }
+ else {
+ GB_log(gb, "Sleeping (%d cycles to next event)\n", -gb->display_cycles / 2);
+ }
+ GB_log(gb, "LY: %d\n", gb->io_registers[GB_IO_LY]);
+ GB_log(gb, "LYC: %d\n", gb->io_registers[GB_IO_LYC]);
+ GB_log(gb, "Window position: %d, %d\n", (signed) gb->io_registers[GB_IO_WX] - 7, gb->io_registers[GB_IO_WY]);
+ GB_log(gb, "Interrupt line: %s\n", gb->stat_interrupt_line? "On" : "Off");
+
+ return true;
+}
+
+static bool apu(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ NO_MODIFIERS
+ if (strlen(lstrip(arguments))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+
+ GB_log(gb, "Current state: ");
+ if (!gb->apu.global_enable) {
+ GB_log(gb, "Disabled\n");
+ }
+ else {
+ GB_log(gb, "Enabled\n");
+ for (uint8_t channel = 0; channel < GB_N_CHANNELS; channel++) {
+ GB_log(gb, "CH%u is %s, DAC %s; current sample = 0x%x\n", channel + 1,
+ gb->apu.is_active[channel] ? "active " : "inactive",
+ GB_apu_is_DAC_enabled(gb, channel) ? "active " : "inactive",
+ gb->apu.samples[channel]);
+ }
+ }
+
+ GB_log(gb, "SO1 (left output): volume %u,", gb->io_registers[GB_IO_NR50] & 0x07);
+ if (gb->io_registers[GB_IO_NR51] & 0x0f) {
+ for (uint8_t channel = 0, mask = 0x01; channel < GB_N_CHANNELS; channel++, mask <<= 1) {
+ if (gb->io_registers[GB_IO_NR51] & mask) {
+ GB_log(gb, " CH%u", channel + 1);
+ }
+ }
+ }
+ else {
+ GB_log(gb, " no channels");
+ }
+ GB_log(gb, "%s\n", gb->io_registers[GB_IO_NR50] & 0x80 ? " VIN": "");
+
+ GB_log(gb, "SO2 (right output): volume %u,", gb->io_registers[GB_IO_NR50] & 0x70 >> 4);
+ if (gb->io_registers[GB_IO_NR51] & 0xf0) {
+ for (uint8_t channel = 0, mask = 0x10; channel < GB_N_CHANNELS; channel++, mask <<= 1) {
+ if (gb->io_registers[GB_IO_NR51] & mask) {
+ GB_log(gb, " CH%u", channel + 1);
+ }
+ }
+ }
+ else {
+ GB_log(gb, " no channels");
+ }
+ GB_log(gb, "%s\n", gb->io_registers[GB_IO_NR50] & 0x80 ? " VIN": "");
+
+
+ for (uint8_t channel = GB_SQUARE_1; channel <= GB_SQUARE_2; channel++) {
+ GB_log(gb, "\nCH%u:\n", channel + 1);
+ GB_log(gb, " Current volume: %u, current sample length: %u APU ticks (next in %u ticks)\n",
+ gb->apu.square_channels[channel].current_volume,
+ (gb->apu.square_channels[channel].sample_length ^ 0x7FF) * 2 + 1,
+ gb->apu.square_channels[channel].sample_countdown);
+
+ uint8_t nrx2 = gb->io_registers[channel == GB_SQUARE_1? GB_IO_NR12 : GB_IO_NR22];
+ GB_log(gb, " %u 256 Hz ticks till next volume %screase (out of %u)\n",
+ gb->apu.square_channels[channel].volume_countdown,
+ nrx2 & 8 ? "in" : "de",
+ nrx2 & 7);
+
+ uint8_t duty = gb->io_registers[channel == GB_SQUARE_1? GB_IO_NR11 :GB_IO_NR21] >> 6;
+ GB_log(gb, " Duty cycle %s%% (%s), current index %u/8%s\n",
+ duty > 3? "" : (const char *[]){"12.5", " 25", " 50", " 75"}[duty],
+ duty > 3? "" : (const char *[]){"_______-", "-______-", "-____---", "_------_"}[duty],
+ gb->apu.square_channels[channel].current_sample_index & 0x7f,
+ gb->apu.square_channels[channel].current_sample_index >> 7 ? " (suppressed)" : "");
+
+ if (channel == GB_SQUARE_1) {
+ GB_log(gb, " Frequency sweep %s and %s (next in %u APU ticks)\n",
+ gb->apu.sweep_enabled? "active" : "inactive",
+ gb->apu.sweep_decreasing? "decreasing" : "increasing",
+ gb->apu.square_sweep_calculate_countdown);
+ }
+
+ if (gb->apu.square_channels[channel].length_enabled) {
+ GB_log(gb, " Channel will end in %u 256 Hz ticks\n",
+ gb->apu.square_channels[channel].pulse_length);
+ }
+ }
+
+
+ GB_log(gb, "\nCH3:\n");
+ GB_log(gb, " Wave:");
+ for (uint8_t i = 0; i < 32; i++) {
+ GB_log(gb, "%s%X", i%4?"":" ", gb->apu.wave_channel.wave_form[i]);
+ }
+ GB_log(gb, "\n");
+ GB_log(gb, " Current position: %u\n", gb->apu.wave_channel.current_sample_index);
+
+ GB_log(gb, " Volume %s (right-shifted %u times)\n",
+ gb->apu.wave_channel.shift > 4? "" : (const char *[]){"100%", "50%", "25%", "", "muted"}[gb->apu.wave_channel.shift],
+ gb->apu.wave_channel.shift);
+
+ GB_log(gb, " Current sample length: %u APU ticks (next in %u ticks)\n",
+ gb->apu.wave_channel.sample_length ^ 0x7ff,
+ gb->apu.wave_channel.sample_countdown);
+
+ if (gb->apu.wave_channel.length_enabled) {
+ GB_log(gb, " Channel will end in %u 256 Hz ticks\n",
+ gb->apu.wave_channel.pulse_length);
+ }
+
+
+ GB_log(gb, "\nCH4:\n");
+ GB_log(gb, " Current volume: %u, current sample length: %u APU ticks (next in %u ticks)\n",
+ gb->apu.noise_channel.current_volume,
+ gb->apu.noise_channel.sample_length * 4 + 3,
+ gb->apu.noise_channel.sample_countdown);
+
+ GB_log(gb, " %u 256 Hz ticks till next volume %screase (out of %u)\n",
+ gb->apu.noise_channel.volume_countdown,
+ gb->io_registers[GB_IO_NR42] & 8 ? "in" : "de",
+ gb->io_registers[GB_IO_NR42] & 7);
+
+ GB_log(gb, " LFSR in %u-step mode, current value ",
+ gb->apu.noise_channel.narrow? 7 : 15);
+ for (uint16_t lfsr = gb->apu.noise_channel.lfsr, i = 15; i--; lfsr <<= 1) {
+ GB_log(gb, "%u%s", (lfsr >> 14) & 1, i%4 ? "" : " ");
+ }
+
+ if (gb->apu.noise_channel.length_enabled) {
+ GB_log(gb, " Channel will end in %u 256 Hz ticks\n",
+ gb->apu.noise_channel.pulse_length);
+ }
+
+
+ GB_log(gb, "\n\nReminder: APU ticks are @ 2 MiHz\n");
+
+ return true;
+}
+
+static char *wave_completer(GB_gameboy_t *gb, const char *string, uintptr_t *context)
+{
+ size_t length = strlen(string);
+ const char *suggestions[] = {"c", "f", "l"};
+ while (*context < sizeof(suggestions) / sizeof(suggestions[0])) {
+ if (memcmp(string, suggestions[*context], length) == 0) {
+ return strdup(suggestions[(*context)++] + length);
+ }
+ (*context)++;
+ }
+ return NULL;
+}
+
+static bool wave(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command)
+{
+ if (strlen(lstrip(arguments)) || (modifiers && !strchr("fcl", modifiers[0]))) {
+ print_usage(gb, command);
+ return true;
+ }
+
+ uint8_t shift_amount = 1, mask;
+ if (modifiers) {
+ switch (modifiers[0]) {
+ case 'c':
+ shift_amount = 2;
+ break;
+ case 'l':
+ shift_amount = 8;
+ break;
+ }
+ }
+ mask = (0xf << (shift_amount - 1)) & 0xf;
+
+ for (int8_t cur_val = 0xf & mask; cur_val >= 0; cur_val -= shift_amount) {
+ for (uint8_t i = 0; i < 32; i++) {
+ if ((gb->apu.wave_channel.wave_form[i] & mask) == cur_val) {
+ GB_log(gb, "%X", gb->apu.wave_channel.wave_form[i]);
+ }
+ else {
+ GB_log(gb, "%c", i%4 == 2 ? '-' : ' ');
+ }
+ }
+ GB_log(gb, "\n");
+ }
+
+ return true;
+}
+
+static bool help(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *command);
+
+#define HELP_NEWLINE "\n "
+
+/* Commands without implementations are aliases of the previous non-alias commands */
+static const debugger_command_t commands[] = {
+ {"continue", 1, cont, "Continue running until next stop"},
+ {"next", 1, next, "Run the next instruction, skipping over function calls"},
+ {"step", 1, step, "Run the next instruction, stepping into function calls"},
+ {"finish", 1, finish, "Run until the current function returns"},
+ {"backtrace", 2, backtrace, "Displays the current call stack"},
+ {"bt", 2, }, /* Alias */
+ {"sld", 3, stack_leak_detection, "Like finish, but stops if a stack leak is detected"},
+ {"ticks", 2, ticks, "Displays the number of CPU ticks since the last time 'ticks' was" HELP_NEWLINE
+ "used"},
+ {"registers", 1, registers, "Print values of processor registers and other important registers"},
+ {"cartridge", 2, mbc, "Displays information about the MBC and cartridge"},
+ {"mbc", 3, }, /* Alias */
+ {"apu", 3, apu, "Displays information about the current state of the audio chip"},
+ {"wave", 3, wave, "Prints a visual representation of the wave RAM." HELP_NEWLINE
+ "Modifiers can be used for a (f)ull print (the default)," HELP_NEWLINE
+ "a more (c)ompact one, or a one-(l)iner", "", "(f|c|l)", .modifiers_completer = wave_completer},
+ {"lcd", 3, lcd, "Displays information about the current state of the LCD controller"},
+ {"palettes", 3, palettes, "Displays the current CGB palettes"},
+ {"softbreak", 2, softbreak, "Enables or disables software breakpoints", "(on|off)", .argument_completer = on_off_completer},
+ {"breakpoint", 1, breakpoint, "Add a new breakpoint at the specified address/expression" HELP_NEWLINE
+ "Can also modify the condition of existing breakpoints." HELP_NEWLINE
+ "If the j modifier is used, the breakpoint will occur just before" HELP_NEWLINE
+ "jumping to the target.",
+ "[ if ]", "j",
+ .argument_completer = symbol_completer, .modifiers_completer = j_completer},
+ {"delete", 2, delete, "Delete a breakpoint by its address, or all breakpoints", "[]", .argument_completer = symbol_completer},
+ {"watch", 1, watch, "Add a new watchpoint at the specified address/expression." HELP_NEWLINE
+ "Can also modify the condition and type of existing watchpoints." HELP_NEWLINE
+ "Default watchpoint type is write-only.",
+ "[ if ]", "(r|w|rw)",
+ .argument_completer = symbol_completer, .modifiers_completer = rw_completer
+ },
+ {"unwatch", 3, unwatch, "Delete a watchpoint by its address, or all watchpoints", "[]", .argument_completer = symbol_completer},
+ {"list", 1, list, "List all set breakpoints and watchpoints"},
+ {"print", 1, print, "Evaluate and print an expression" HELP_NEWLINE
+ "Use modifier to format as an address (a, default) or as a number in" HELP_NEWLINE
+ "decimal (d), hexadecimal (x), octal (o) or binary (b).",
+ "", "format", .argument_completer = symbol_completer, .modifiers_completer = format_completer},
+ {"eval", 2, }, /* Alias */
+ {"examine", 2, examine, "Examine values at address", "", "count", .argument_completer = symbol_completer},
+ {"x", 1, }, /* Alias */
+ {"disassemble", 1, disassemble, "Disassemble instructions at address", "", "count", .argument_completer = symbol_completer},
+
+
+ {"help", 1, help, "List available commands or show help for the specified command", "[]"},
+ {NULL,}, /* Null terminator */
+};
+
+static const debugger_command_t *find_command(const char *string)
+{
+ size_t length = strlen(string);
+ for (const debugger_command_t *command = commands; command->command; command++) {
+ if (command->min_length > length) continue;
+ if (memcmp(command->command, string, length) == 0) { /* Is a substring? */
+ /* Aliases */
+ while (!command->implementation) {
+ command--;
+ }
+ return command;
+ }
+ }
+
+ return NULL;
+}
+
+static void print_command_shortcut(GB_gameboy_t *gb, const debugger_command_t *command)
+{
+ GB_attributed_log(gb, GB_LOG_BOLD | GB_LOG_UNDERLINE, "%.*s", command->min_length, command->command);
+ GB_attributed_log(gb, GB_LOG_BOLD, "%s", command->command + command->min_length);
+}
+
+static void print_command_description(GB_gameboy_t *gb, const debugger_command_t *command)
+{
+ print_command_shortcut(gb, command);
+ GB_log(gb, ": ");
+ GB_log(gb, (const char *)&" %s\n" + strlen(command->command), command->help_string);
+}
+
+static bool help(GB_gameboy_t *gb, char *arguments, char *modifiers, const debugger_command_t *ignored)
+{
+ const debugger_command_t *command = find_command(arguments);
+ if (command) {
+ print_command_description(gb, command);
+ GB_log(gb, "\n");
+ print_usage(gb, command);
+
+ command++;
+ if (command->command && !command->implementation) { /* Command has aliases*/
+ GB_log(gb, "\nAliases: ");
+ do {
+ print_command_shortcut(gb, command);
+ GB_log(gb, " ");
+ command++;
+ } while (command->command && !command->implementation);
+ GB_log(gb, "\n");
+ }
+ return true;
+ }
+ for (command = commands; command->command; command++) {
+ if (command->help_string) {
+ print_command_description(gb, command);
+ }
+ }
+ return true;
+}
+
+void GB_debugger_call_hook(GB_gameboy_t *gb, uint16_t call_addr)
+{
+ /* Called just after the CPU calls a function/enters an interrupt/etc... */
+
+ if (gb->stack_leak_detection) {
+ if (gb->debug_call_depth >= sizeof(gb->sp_for_call_depth) / sizeof(gb->sp_for_call_depth[0])) {
+ GB_log(gb, "Potential stack overflow detected (Functions nest too much). \n");
+ gb->debug_stopped = true;
+ }
+ else {
+ gb->sp_for_call_depth[gb->debug_call_depth] = gb->registers[GB_REGISTER_SP];
+ gb->addr_for_call_depth[gb->debug_call_depth] = gb->pc;
+ }
+ }
+
+ if (gb->backtrace_size < sizeof(gb->backtrace_sps) / sizeof(gb->backtrace_sps[0])) {
+
+ while (gb->backtrace_size) {
+ if (gb->backtrace_sps[gb->backtrace_size - 1] < gb->registers[GB_REGISTER_SP]) {
+ gb->backtrace_size--;
+ }
+ else {
+ break;
+ }
+ }
+
+ gb->backtrace_sps[gb->backtrace_size] = gb->registers[GB_REGISTER_SP];
+ gb->backtrace_returns[gb->backtrace_size].bank = bank_for_addr(gb, call_addr);
+ gb->backtrace_returns[gb->backtrace_size].addr = call_addr;
+ gb->backtrace_size++;
+ }
+
+ gb->debug_call_depth++;
+}
+
+void GB_debugger_ret_hook(GB_gameboy_t *gb)
+{
+ /* Called just before the CPU runs ret/reti */
+
+ gb->debug_call_depth--;
+
+ if (gb->stack_leak_detection) {
+ if (gb->debug_call_depth < 0) {
+ GB_log(gb, "Function finished without a stack leak.\n");
+ gb->debug_stopped = true;
+ }
+ else {
+ if (gb->registers[GB_REGISTER_SP] != gb->sp_for_call_depth[gb->debug_call_depth]) {
+ GB_log(gb, "Stack leak detected for function %s!\n", value_to_string(gb, gb->addr_for_call_depth[gb->debug_call_depth], true));
+ GB_log(gb, "SP is $%04x, should be $%04x.\n", gb->registers[GB_REGISTER_SP],
+ gb->sp_for_call_depth[gb->debug_call_depth]);
+ gb->debug_stopped = true;
+ }
+ }
+ }
+
+ while (gb->backtrace_size) {
+ if (gb->backtrace_sps[gb->backtrace_size - 1] <= gb->registers[GB_REGISTER_SP]) {
+ gb->backtrace_size--;
+ }
+ else {
+ break;
+ }
+ }
+}
+
+static bool _GB_debugger_test_write_watchpoint(GB_gameboy_t *gb, value_t addr, uint8_t value)
+{
+ uint16_t index = find_watchpoint(gb, addr);
+ uint32_t key = WP_KEY(addr);
+
+ if (index < gb->n_watchpoints && gb->watchpoints[index].key == key) {
+ if (!(gb->watchpoints[index].flags & GB_WATCHPOINT_W)) {
+ return false;
+ }
+ if (!gb->watchpoints[index].condition) {
+ gb->debug_stopped = true;
+ GB_log(gb, "Watchpoint: [%s] = $%02x\n", debugger_value_to_string(gb, addr, true), value);
+ return true;
+ }
+ bool error;
+ bool condition = debugger_evaluate(gb, gb->watchpoints[index].condition,
+ (unsigned)strlen(gb->watchpoints[index].condition), &error, &addr.value, &value).value;
+ if (error) {
+ /* Should never happen */
+ GB_log(gb, "An internal error has occured\n");
+ return false;
+ }
+ if (condition) {
+ gb->debug_stopped = true;
+ GB_log(gb, "Watchpoint: [%s] = $%02x\n", debugger_value_to_string(gb, addr, true), value);
+ return true;
+ }
+ }
+ return false;
+}
+
+void GB_debugger_test_write_watchpoint(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ if (gb->debug_stopped) return;
+
+ /* Try any-bank breakpoint */
+ value_t full_addr = (VALUE_16(addr));
+ if (_GB_debugger_test_write_watchpoint(gb, full_addr, value)) return;
+
+ /* Try bank-specific breakpoint */
+ full_addr.has_bank = true;
+ full_addr.bank = bank_for_addr(gb, addr);
+ _GB_debugger_test_write_watchpoint(gb, full_addr, value);
+}
+
+static bool _GB_debugger_test_read_watchpoint(GB_gameboy_t *gb, value_t addr)
+{
+ uint16_t index = find_watchpoint(gb, addr);
+ uint32_t key = WP_KEY(addr);
+
+ if (index < gb->n_watchpoints && gb->watchpoints[index].key == key) {
+ if (!(gb->watchpoints[index].flags & GB_WATCHPOINT_R)) {
+ return false;
+ }
+ if (!gb->watchpoints[index].condition) {
+ gb->debug_stopped = true;
+ GB_log(gb, "Watchpoint: [%s]\n", debugger_value_to_string(gb, addr, true));
+ return true;
+ }
+ bool error;
+ bool condition = debugger_evaluate(gb, gb->watchpoints[index].condition,
+ (unsigned)strlen(gb->watchpoints[index].condition), &error, &addr.value, NULL).value;
+ if (error) {
+ /* Should never happen */
+ GB_log(gb, "An internal error has occured\n");
+ return false;
+ }
+ if (condition) {
+ gb->debug_stopped = true;
+ GB_log(gb, "Watchpoint: [%s]\n", debugger_value_to_string(gb, addr, true));
+ return true;
+ }
+ }
+ return false;
+}
+
+void GB_debugger_test_read_watchpoint(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (gb->debug_stopped) return;
+
+ /* Try any-bank breakpoint */
+ value_t full_addr = (VALUE_16(addr));
+ if (_GB_debugger_test_read_watchpoint(gb, full_addr)) return;
+
+ /* Try bank-specific breakpoint */
+ full_addr.has_bank = true;
+ full_addr.bank = bank_for_addr(gb, addr);
+ _GB_debugger_test_read_watchpoint(gb, full_addr);
+}
+
+/* Returns true if debugger waits for more commands */
+bool GB_debugger_execute_command(GB_gameboy_t *gb, char *input)
+{
+ if (!input[0]) {
+ return true;
+ }
+
+ char *command_string = input;
+ char *arguments = strchr(input, ' ');
+ if (arguments) {
+ /* Actually "split" the string. */
+ arguments[0] = 0;
+ arguments++;
+ }
+ else {
+ arguments = "";
+ }
+
+ char *modifiers = strchr(command_string, '/');
+ if (modifiers) {
+ /* Actually "split" the string. */
+ modifiers[0] = 0;
+ modifiers++;
+ }
+
+ const debugger_command_t *command = find_command(command_string);
+ if (command) {
+ return command->implementation(gb, arguments, modifiers, command);
+ }
+ else {
+ GB_log(gb, "%s: no such command.\n", command_string);
+ return true;
+ }
+}
+
+/* Returns true if debugger waits for more commands */
+char *GB_debugger_complete_substring(GB_gameboy_t *gb, char *input, uintptr_t *context)
+{
+ char *command_string = input;
+ char *arguments = strchr(input, ' ');
+ if (arguments) {
+ /* Actually "split" the string. */
+ arguments[0] = 0;
+ arguments++;
+ }
+
+ char *modifiers = strchr(command_string, '/');
+ if (modifiers) {
+ /* Actually "split" the string. */
+ modifiers[0] = 0;
+ modifiers++;
+ }
+
+ const debugger_command_t *command = find_command(command_string);
+ if (command && command->implementation == help && arguments) {
+ command_string = arguments;
+ arguments = NULL;
+ }
+
+ /* No commands and no modifiers, complete the command */
+ if (!arguments && !modifiers) {
+ size_t length = strlen(command_string);
+ if (*context >= sizeof(commands) / sizeof(commands[0])) {
+ return NULL;
+ }
+ for (const debugger_command_t *command = &commands[*context]; command->command; command++) {
+ (*context)++;
+ if (memcmp(command->command, command_string, length) == 0) { /* Is a substring? */
+ return strdup(command->command + length);
+ }
+ }
+ return NULL;
+ }
+
+ if (command) {
+ if (arguments) {
+ if (command->argument_completer) {
+ return command->argument_completer(gb, arguments, context);
+ }
+ return NULL;
+ }
+
+ if (modifiers) {
+ if (command->modifiers_completer) {
+ return command->modifiers_completer(gb, modifiers, context);
+ }
+ return NULL;
+ }
+ }
+ return NULL;
+}
+
+typedef enum {
+ JUMP_TO_NONE,
+ JUMP_TO_BREAK,
+ JUMP_TO_NONTRIVIAL,
+} jump_to_return_t;
+
+static jump_to_return_t test_jump_to_breakpoints(GB_gameboy_t *gb, uint16_t *address);
+
+void GB_debugger_run(GB_gameboy_t *gb)
+{
+ if (gb->debug_disable) return;
+
+ char *input = NULL;
+ if (gb->debug_next_command && gb->debug_call_depth <= 0 && !gb->halted) {
+ gb->debug_stopped = true;
+ }
+ if (gb->debug_fin_command && gb->debug_call_depth == -1) {
+ gb->debug_stopped = true;
+ }
+ if (gb->debug_stopped) {
+ GB_cpu_disassemble(gb, gb->pc, 5);
+ }
+next_command:
+ if (input) {
+ free(input);
+ }
+ if (gb->breakpoints && !gb->debug_stopped && should_break(gb, gb->pc, false)) {
+ gb->debug_stopped = true;
+ GB_log(gb, "Breakpoint: PC = %s\n", value_to_string(gb, gb->pc, true));
+ GB_cpu_disassemble(gb, gb->pc, 5);
+ }
+
+ if (gb->breakpoints && !gb->debug_stopped) {
+ uint16_t address = 0;
+ jump_to_return_t jump_to_result = test_jump_to_breakpoints(gb, &address);
+
+ bool should_delete_state = true;
+ if (gb->nontrivial_jump_state && should_break(gb, gb->pc, true)) {
+ if (gb->non_trivial_jump_breakpoint_occured) {
+ gb->non_trivial_jump_breakpoint_occured = false;
+ }
+ else {
+ gb->non_trivial_jump_breakpoint_occured = true;
+ GB_log(gb, "Jumping to breakpoint: PC = %s\n", value_to_string(gb, gb->pc, true));
+ GB_cpu_disassemble(gb, gb->pc, 5);
+ GB_load_state_from_buffer(gb, gb->nontrivial_jump_state, -1);
+ gb->debug_stopped = true;
+ }
+ }
+ else if (jump_to_result == JUMP_TO_BREAK) {
+ gb->debug_stopped = true;
+ GB_log(gb, "Jumping to breakpoint: PC = %s\n", value_to_string(gb, address, true));
+ GB_cpu_disassemble(gb, gb->pc, 5);
+ gb->non_trivial_jump_breakpoint_occured = false;
+ }
+ else if (jump_to_result == JUMP_TO_NONTRIVIAL) {
+ if (!gb->nontrivial_jump_state) {
+ gb->nontrivial_jump_state = malloc(GB_get_save_state_size(gb));
+ }
+ GB_save_state_to_buffer(gb, gb->nontrivial_jump_state);
+ gb->non_trivial_jump_breakpoint_occured = false;
+ should_delete_state = false;
+ }
+ else {
+ gb->non_trivial_jump_breakpoint_occured = false;
+ }
+
+ if (should_delete_state) {
+ if (gb->nontrivial_jump_state) {
+ free(gb->nontrivial_jump_state);
+ gb->nontrivial_jump_state = NULL;
+ }
+ }
+ }
+
+ if (gb->debug_stopped && !gb->debug_disable) {
+ gb->debug_next_command = false;
+ gb->debug_fin_command = false;
+ gb->stack_leak_detection = false;
+ input = gb->input_callback(gb);
+
+ if (input == NULL) {
+ /* Debugging is no currently available, continue running */
+ gb->debug_stopped = false;
+ return;
+ }
+
+ if (GB_debugger_execute_command(gb, input)) {
+ goto next_command;
+ }
+
+ free(input);
+ }
+}
+
+void GB_debugger_handle_async_commands(GB_gameboy_t *gb)
+{
+ char *input = NULL;
+
+ while (gb->async_input_callback && (input = gb->async_input_callback(gb))) {
+ GB_debugger_execute_command(gb, input);
+ free(input);
+ }
+}
+
+void GB_debugger_add_symbol(GB_gameboy_t *gb, uint16_t bank, uint16_t address, const char *symbol)
+{
+ bank &= 0x1FF;
+
+ if (!gb->bank_symbols[bank]) {
+ gb->bank_symbols[bank] = GB_map_alloc();
+ }
+ GB_bank_symbol_t *allocated_symbol = GB_map_add_symbol(gb->bank_symbols[bank], address, symbol);
+ if (allocated_symbol) {
+ GB_reversed_map_add_symbol(&gb->reversed_symbol_map, bank, allocated_symbol);
+ }
+}
+
+void GB_debugger_load_symbol_file(GB_gameboy_t *gb, const char *path)
+{
+ FILE *f = fopen(path, "r");
+ if (!f) return;
+
+ char *line = NULL;
+ size_t size = 0;
+ size_t length = 0;
+ while ((length = getline(&line, &size, f)) != -1) {
+ for (unsigned i = 0; i < length; i++) {
+ if (line[i] == ';' || line[i] == '\n' || line[i] == '\r') {
+ line[i] = 0;
+ length = i;
+ break;
+ }
+ }
+ if (length == 0) continue;
+
+ unsigned bank, address;
+ char symbol[length];
+
+ if (sscanf(line, "%x:%x %s", &bank, &address, symbol) == 3) {
+ GB_debugger_add_symbol(gb, bank, address, symbol);
+ }
+ }
+ free(line);
+ fclose(f);
+}
+
+void GB_debugger_clear_symbols(GB_gameboy_t *gb)
+{
+ for (unsigned i = sizeof(gb->bank_symbols) / sizeof(gb->bank_symbols[0]); i--;) {
+ if (gb->bank_symbols[i]) {
+ GB_map_free(gb->bank_symbols[i]);
+ gb->bank_symbols[i] = 0;
+ }
+ }
+ for (unsigned i = sizeof(gb->reversed_symbol_map.buckets) / sizeof(gb->reversed_symbol_map.buckets[0]); i--;) {
+ while (gb->reversed_symbol_map.buckets[i]) {
+ GB_symbol_t *next = gb->reversed_symbol_map.buckets[i]->next;
+ free(gb->reversed_symbol_map.buckets[i]);
+ gb->reversed_symbol_map.buckets[i] = next;
+ }
+ }
+}
+
+const GB_bank_symbol_t *GB_debugger_find_symbol(GB_gameboy_t *gb, uint16_t addr)
+{
+ uint16_t bank = bank_for_addr(gb, addr);
+
+ const GB_bank_symbol_t *symbol = GB_map_find_symbol(gb->bank_symbols[bank], addr);
+ if (symbol) return symbol;
+ if (bank != 0) return GB_map_find_symbol(gb->bank_symbols[0], addr); /* Maybe the symbol incorrectly uses bank 0? */
+
+ return NULL;
+}
+
+const char *GB_debugger_name_for_address(GB_gameboy_t *gb, uint16_t addr)
+{
+ const GB_bank_symbol_t *symbol = GB_debugger_find_symbol(gb, addr);
+ if (symbol && symbol->addr == addr) return symbol->name;
+ return NULL;
+}
+
+/* The public version of debugger_evaluate */
+bool GB_debugger_evaluate(GB_gameboy_t *gb, const char *string, uint16_t *result, uint16_t *result_bank)
+{
+ bool error = false;
+ value_t value = debugger_evaluate(gb, string, strlen(string), &error, NULL, NULL);
+ if (result) {
+ *result = value.value;
+ }
+ if (result_bank) {
+ *result_bank = value.has_bank? value.value : -1;
+ }
+ return error;
+}
+
+void GB_debugger_break(GB_gameboy_t *gb)
+{
+ gb->debug_stopped = true;
+}
+
+bool GB_debugger_is_stopped(GB_gameboy_t *gb)
+{
+ return gb->debug_stopped;
+}
+
+void GB_debugger_set_disabled(GB_gameboy_t *gb, bool disabled)
+{
+ gb->debug_disable = disabled;
+}
+
+/* Jump-to breakpoints */
+
+static bool is_in_trivial_memory(uint16_t addr)
+{
+ /* ROM */
+ if (addr < 0x8000) {
+ return true;
+ }
+
+ /* HRAM */
+ if (addr >= 0xFF80 && addr < 0xFFFF) {
+ return true;
+ }
+
+ /* RAM */
+ if (addr >= 0xC000 && addr < 0xE000) {
+ return true;
+ }
+
+ return false;
+}
+
+typedef uint16_t GB_opcode_address_getter_t(GB_gameboy_t *gb, uint8_t opcode);
+
+uint16_t trivial_1(GB_gameboy_t *gb, uint8_t opcode)
+{
+ return gb->pc + 1;
+}
+
+uint16_t trivial_2(GB_gameboy_t *gb, uint8_t opcode)
+{
+ return gb->pc + 2;
+}
+
+uint16_t trivial_3(GB_gameboy_t *gb, uint8_t opcode)
+{
+ return gb->pc + 3;
+}
+
+static uint16_t jr_r8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ return gb->pc + 2 + (int8_t)GB_read_memory(gb, gb->pc + 1);
+}
+
+static bool condition_code(GB_gameboy_t *gb, uint8_t opcode)
+{
+ switch ((opcode >> 3) & 0x3) {
+ case 0:
+ return !(gb->registers[GB_REGISTER_AF] & GB_ZERO_FLAG);
+ case 1:
+ return (gb->registers[GB_REGISTER_AF] & GB_ZERO_FLAG);
+ case 2:
+ return !(gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG);
+ case 3:
+ return (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG);
+ }
+
+ return false;
+}
+
+static uint16_t jr_cc_r8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ if (!condition_code(gb, opcode)) {
+ return gb->pc + 2;
+ }
+
+ return gb->pc + 2 + (int8_t)GB_read_memory(gb, gb->pc + 1);
+}
+
+static uint16_t ret(GB_gameboy_t *gb, uint8_t opcode)
+{
+ return GB_read_memory(gb, gb->registers[GB_REGISTER_SP]) |
+ (GB_read_memory(gb, gb->registers[GB_REGISTER_SP] + 1) << 8);
+}
+
+
+static uint16_t ret_cc(GB_gameboy_t *gb, uint8_t opcode)
+{
+ if (condition_code(gb, opcode)) {
+ return ret(gb, opcode);
+ }
+ else {
+ return gb->pc + 1;
+ }
+}
+
+static uint16_t jp_a16(GB_gameboy_t *gb, uint8_t opcode)
+{
+ return GB_read_memory(gb, gb->pc + 1) |
+ (GB_read_memory(gb, gb->pc + 2) << 8);
+}
+
+static uint16_t jp_cc_a16(GB_gameboy_t *gb, uint8_t opcode)
+{
+ if (condition_code(gb, opcode)) {
+ return jp_a16(gb, opcode);
+ }
+ else {
+ return gb->pc + 3;
+ }
+}
+
+static uint16_t rst(GB_gameboy_t *gb, uint8_t opcode)
+{
+ return opcode ^ 0xC7;
+}
+
+static uint16_t jp_hl(GB_gameboy_t *gb, uint8_t opcode)
+{
+ return gb->hl;
+}
+
+static GB_opcode_address_getter_t *opcodes[256] = {
+ /* X0 X1 X2 X3 X4 X5 X6 X7 */
+ /* X8 X9 Xa Xb Xc Xd Xe Xf */
+ trivial_1, trivial_3, trivial_1, trivial_1, trivial_1, trivial_1, trivial_2, trivial_1, /* 0X */
+ trivial_3, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_2, trivial_1,
+ trivial_2, trivial_3, trivial_1, trivial_1, trivial_1, trivial_1, trivial_2, trivial_1, /* 1X */
+ jr_r8, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_2, trivial_1,
+ jr_cc_r8, trivial_3, trivial_1, trivial_1, trivial_1, trivial_1, trivial_2, trivial_1, /* 2X */
+ jr_cc_r8, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_2, trivial_1,
+ jr_cc_r8, trivial_3, trivial_1, trivial_1, trivial_1, trivial_1, trivial_2, trivial_1, /* 3X */
+ jr_cc_r8, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_2, trivial_1,
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, /* 4X */
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1,
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, /* 5X */
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1,
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, /* 6X */
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1,
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, NULL, trivial_1, /* 7X */
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1,
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, /* 8X */
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1,
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, /* 9X */
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1,
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, /* aX */
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1,
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, /* bX */
+ trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1, trivial_1,
+ ret_cc, trivial_1, jp_cc_a16, jp_a16, jp_cc_a16, trivial_1, trivial_2, rst, /* cX */
+ ret_cc, ret, jp_cc_a16, trivial_2, jp_cc_a16, jp_a16, trivial_2, rst,
+ ret_cc, trivial_1, jp_cc_a16, NULL, jp_cc_a16, trivial_1, trivial_2, rst, /* dX */
+ ret_cc, ret, jp_cc_a16, NULL, jp_cc_a16, NULL, trivial_2, rst,
+ trivial_2, trivial_1, trivial_1, NULL, NULL, trivial_1, trivial_2, rst, /* eX */
+ trivial_2, jp_hl, trivial_3, NULL, NULL, NULL, trivial_2, rst,
+ trivial_2, trivial_1, trivial_1, trivial_1, NULL, trivial_1, trivial_2, rst, /* fX */
+ trivial_2, trivial_1, trivial_3, trivial_1, NULL, NULL, trivial_2, rst,
+};
+
+static jump_to_return_t test_jump_to_breakpoints(GB_gameboy_t *gb, uint16_t *address)
+{
+ if (!gb->has_jump_to_breakpoints) return JUMP_TO_NONE;
+
+ if (!is_in_trivial_memory(gb->pc) || !is_in_trivial_memory(gb->pc + 2) ||
+ !is_in_trivial_memory(gb->registers[GB_REGISTER_SP]) || !is_in_trivial_memory(gb->registers[GB_REGISTER_SP] + 1)) {
+ return JUMP_TO_NONTRIVIAL;
+ }
+
+ /* Interrupts */
+ if (gb->ime) {
+ for (unsigned i = 0; i < 5; i++) {
+ if ((gb->interrupt_enable & (1 << i)) && (gb->io_registers[GB_IO_IF] & (1 << i))) {
+ if (should_break(gb, 0x40 + i * 8, true)) {
+ if (address) {
+ *address = 0x40 + i * 8;
+ }
+ return JUMP_TO_BREAK;
+ }
+ }
+ }
+ }
+
+ uint16_t n_watchpoints = gb->n_watchpoints;
+ gb->n_watchpoints = 0;
+
+ uint8_t opcode = GB_read_memory(gb, gb->pc);
+
+ if (opcode == 0x76) {
+ gb->n_watchpoints = n_watchpoints;
+ if (gb->ime) { /* Already handled in above */
+ return JUMP_TO_NONE;
+ }
+
+ if (gb->interrupt_enable & gb->io_registers[GB_IO_IF] & 0x1F) {
+ return JUMP_TO_NONTRIVIAL; /* HALT bug could occur */
+ }
+
+ return JUMP_TO_NONE;
+ }
+
+ GB_opcode_address_getter_t *getter = opcodes[opcode];
+ if (!getter) {
+ gb->n_watchpoints = n_watchpoints;
+ return JUMP_TO_NONE;
+ }
+
+ uint16_t new_pc = getter(gb, opcode);
+
+ gb->n_watchpoints = n_watchpoints;
+
+ if (address) {
+ *address = new_pc;
+ }
+
+ return should_break(gb, new_pc, true) ? JUMP_TO_BREAK : JUMP_TO_NONE;
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/debugger.h b/waterbox/bsnescore/bsnes/gb/Core/debugger.h
new file mode 100644
index 0000000000..0678b30c95
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/debugger.h
@@ -0,0 +1,46 @@
+#ifndef debugger_h
+#define debugger_h
+#include
+#include
+#include "gb_struct_def.h"
+#include "symbol_hash.h"
+
+
+#ifdef GB_INTERNAL
+#ifdef GB_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
+#define GB_debugger_add_symbol(gb, bank, address, symbol) ((void)bank, (void)address, (void)symbol)
+
+#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);
+void GB_debugger_add_symbol(GB_gameboy_t *gb, uint16_t bank, uint16_t address, const char *symbol);
+#endif /* GB_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. */
+char *GB_debugger_complete_substring(GB_gameboy_t *gb, char *input, uintptr_t *context); /* Destroys input, result requires free */
+
+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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/display.c b/waterbox/bsnescore/bsnes/gb/Core/display.c
new file mode 100644
index 0000000000..2eb8c424b5
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/display.c
@@ -0,0 +1,1487 @@
+#include
+#include
+#include
+#include
+#include "gb.h"
+
+/* FIFO functions */
+
+static inline unsigned fifo_size(GB_fifo_t *fifo)
+{
+ return (fifo->write_end - fifo->read_end) & (GB_FIFO_LENGTH - 1);
+}
+
+static void fifo_clear(GB_fifo_t *fifo)
+{
+ fifo->read_end = fifo->write_end = 0;
+}
+
+static GB_fifo_item_t *fifo_pop(GB_fifo_t *fifo)
+{
+ GB_fifo_item_t *ret = &fifo->fifo[fifo->read_end];
+ fifo->read_end++;
+ fifo->read_end &= (GB_FIFO_LENGTH - 1);
+ return ret;
+}
+
+static void fifo_push_bg_row(GB_fifo_t *fifo, uint8_t lower, uint8_t upper, uint8_t palette, bool bg_priority, bool flip_x)
+{
+ if (!flip_x) {
+ UNROLL
+ for (unsigned i = 8; i--;) {
+ fifo->fifo[fifo->write_end] = (GB_fifo_item_t) {
+ (lower >> 7) | ((upper >> 7) << 1),
+ palette,
+ 0,
+ bg_priority,
+ };
+ lower <<= 1;
+ upper <<= 1;
+
+ fifo->write_end++;
+ fifo->write_end &= (GB_FIFO_LENGTH - 1);
+ }
+ }
+ else {
+ UNROLL
+ for (unsigned i = 8; i--;) {
+ fifo->fifo[fifo->write_end] = (GB_fifo_item_t) {
+ (lower & 1) | ((upper & 1) << 1),
+ palette,
+ 0,
+ bg_priority,
+ };
+ lower >>= 1;
+ upper >>= 1;
+
+ fifo->write_end++;
+ fifo->write_end &= (GB_FIFO_LENGTH - 1);
+ }
+ }
+}
+
+static void fifo_overlay_object_row(GB_fifo_t *fifo, uint8_t lower, uint8_t upper, uint8_t palette, bool bg_priority, uint8_t priority, bool flip_x)
+{
+ while (fifo_size(fifo) < 8) {
+ fifo->fifo[fifo->write_end] = (GB_fifo_item_t) {0,};
+ fifo->write_end++;
+ fifo->write_end &= (GB_FIFO_LENGTH - 1);
+ }
+
+ uint8_t flip_xor = flip_x? 0: 0x7;
+
+ UNROLL
+ for (unsigned i = 8; i--;) {
+ uint8_t pixel = (lower >> 7) | ((upper >> 7) << 1);
+ GB_fifo_item_t *target = &fifo->fifo[(fifo->read_end + (i ^ flip_xor)) & (GB_FIFO_LENGTH - 1)];
+ if (pixel != 0 && (target->pixel == 0 || target->priority > priority)) {
+ target->pixel = pixel;
+ target->palette = palette;
+ target->bg_priority = bg_priority;
+ target->priority = priority;
+ }
+ lower <<= 1;
+ upper <<= 1;
+ }
+}
+
+
+/*
+ Each line is 456 cycles. Without scrolling, sprites or a window:
+ Mode 2 - 80 cycles / OAM Transfer
+ Mode 3 - 172 cycles / Rendering
+ Mode 0 - 204 cycles / HBlank
+
+ Mode 1 is VBlank
+ */
+
+#define MODE2_LENGTH (80)
+#define LINE_LENGTH (456)
+#define LINES (144)
+#define WIDTH (160)
+#define BORDERED_WIDTH 256
+#define BORDERED_HEIGHT 224
+#define FRAME_LENGTH (LCDC_PERIOD)
+#define VIRTUAL_LINES (FRAME_LENGTH / LINE_LENGTH) // = 154
+
+typedef struct __attribute__((packed)) {
+ uint8_t y;
+ uint8_t x;
+ uint8_t tile;
+ uint8_t flags;
+} GB_object_t;
+
+static void display_vblank(GB_gameboy_t *gb)
+{
+ gb->vblank_just_occured = true;
+
+ /* TODO: Slow in turbo mode! */
+ if (GB_is_hle_sgb(gb)) {
+ GB_sgb_render(gb);
+ }
+
+ if (gb->turbo) {
+ if (GB_timing_sync_turbo(gb)) {
+ return;
+ }
+ }
+
+ bool is_ppu_stopped = !GB_is_cgb(gb) && gb->stopped && gb->io_registers[GB_IO_LCDC] & 0x80;
+
+ if (!gb->disable_rendering && ((!(gb->io_registers[GB_IO_LCDC] & 0x80) || is_ppu_stopped) || gb->cgb_repeated_a_frame)) {
+ /* LCD is off, set screen to white or black (if LCD is on in stop mode) */
+ if (!GB_is_sgb(gb)) {
+ uint32_t color = 0;
+ if (GB_is_cgb(gb)) {
+ color = GB_convert_rgb15(gb, 0x7FFF, false);
+ }
+ else {
+ color = is_ppu_stopped ?
+ gb->background_palettes_rgb[0] :
+ gb->background_palettes_rgb[4];
+ }
+ if (gb->border_mode == GB_BORDER_ALWAYS) {
+ for (unsigned y = 0; y < LINES; y++) {
+ for (unsigned x = 0; x < WIDTH; x++) {
+ gb ->screen[x + y * BORDERED_WIDTH + (BORDERED_WIDTH - WIDTH) / 2 + (BORDERED_HEIGHT - LINES) / 2 * BORDERED_WIDTH] = color;
+ }
+ }
+ }
+ else {
+ for (unsigned i = 0; i < WIDTH * LINES; i++) {
+ gb ->screen[i] = color;
+ }
+ }
+ }
+ }
+
+ if (gb->border_mode == GB_BORDER_ALWAYS && !GB_is_sgb(gb)) {
+ GB_borrow_sgb_border(gb);
+ uint32_t border_colors[16 * 4];
+
+ if (!gb->has_sgb_border && GB_is_cgb(gb) && gb->model != GB_MODEL_AGB) {
+ static uint16_t colors[] = {
+ 0x2095, 0x5129, 0x1EAF, 0x1EBA, 0x4648,
+ 0x30DA, 0x69AD, 0x2B57, 0x2B5D, 0x632C,
+ 0x1050, 0x3C84, 0x0E07, 0x0E18, 0x2964,
+ };
+ unsigned index = gb->rom? gb->rom[0x14e] % 5 : 0;
+ gb->borrowed_border.palette[0] = colors[index];
+ gb->borrowed_border.palette[10] = colors[5 + index];
+ gb->borrowed_border.palette[14] = colors[10 + index];
+
+ }
+
+ for (unsigned i = 0; i < 16 * 4; i++) {
+ border_colors[i] = GB_convert_rgb15(gb, gb->borrowed_border.palette[i], true);
+ }
+
+ for (unsigned tile_y = 0; tile_y < 28; tile_y++) {
+ for (unsigned tile_x = 0; tile_x < 32; tile_x++) {
+ if (tile_x >= 6 && tile_x < 26 && tile_y >= 5 && tile_y < 23) {
+ continue;
+ }
+ uint16_t tile = gb->borrowed_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->borrowed_border.tiles[(tile & 0xFF) * 64 + (x ^ flip_x) + (y ^ flip_y) * 8] & 0xF;
+ uint32_t *output = gb->screen + tile_x * 8 + x + (tile_y * 8 + y) * 256;
+ if (color == 0) {
+ *output = border_colors[0];
+ }
+ else {
+ *output = border_colors[color + palette * 16];
+ }
+ }
+ }
+ }
+ }
+ }
+ GB_handle_rumble(gb);
+
+ if (gb->vblank_callback) {
+ gb->vblank_callback(gb);
+ }
+ GB_timing_sync(gb);
+}
+
+static inline uint8_t scale_channel(uint8_t x)
+{
+ return (x << 3) | (x >> 2);
+}
+
+static inline uint8_t scale_channel_with_curve(uint8_t x)
+{
+ return (uint8_t[]){0,5,8,11,16,22,28,36,43,51,59,67,77,87,97,107,119,130,141,153,166,177,188,200,209,221,230,238,245,249,252,255}[x];
+}
+
+static inline uint8_t scale_channel_with_curve_agb(uint8_t x)
+{
+ return (uint8_t[]){0,2,5,10,15,20,26,32,38,45,52,60,68,76,84,92,101,110,119,128,138,148,158,168,178,189,199,210,221,232,244,255}[x];
+}
+
+static inline uint8_t scale_channel_with_curve_sgb(uint8_t x)
+{
+ return (uint8_t[]){0,2,5,9,15,20,27,34,42,50,58,67,76,85,94,104,114,123,133,143,153,163,173,182,192,202,211,220,229,238,247,255}[x];
+}
+
+
+uint32_t GB_convert_rgb15(GB_gameboy_t *gb, uint16_t color, bool for_border)
+{
+ uint8_t r = (color) & 0x1F;
+ uint8_t g = (color >> 5) & 0x1F;
+ uint8_t b = (color >> 10) & 0x1F;
+
+ if (gb->color_correction_mode == GB_COLOR_CORRECTION_DISABLED || (for_border && !gb->has_sgb_border)) {
+ r = scale_channel(r);
+ g = scale_channel(g);
+ b = scale_channel(b);
+ }
+ else {
+ if (GB_is_sgb(gb) || for_border) {
+ return gb->rgb_encode_callback(gb,
+ scale_channel_with_curve_sgb(r),
+ scale_channel_with_curve_sgb(g),
+ scale_channel_with_curve_sgb(b));
+ }
+ bool agb = gb->model == GB_MODEL_AGB;
+ r = agb? scale_channel_with_curve_agb(r) : scale_channel_with_curve(r);
+ g = agb? scale_channel_with_curve_agb(g) : scale_channel_with_curve(g);
+ b = agb? scale_channel_with_curve_agb(b) : scale_channel_with_curve(b);
+
+ if (gb->color_correction_mode != GB_COLOR_CORRECTION_CORRECT_CURVES) {
+ uint8_t new_r, new_g, new_b;
+ if (agb) {
+ new_g = (g * 6 + b * 1) / 7;
+ }
+ else {
+ new_g = (g * 3 + b) / 4;
+ }
+ new_r = r;
+ new_b = b;
+ if (gb->color_correction_mode == GB_COLOR_CORRECTION_REDUCE_CONTRAST) {
+ r = new_r;
+ g = new_r;
+ b = new_r;
+
+ new_r = new_r * 7 / 8 + ( g + b) / 16;
+ new_g = new_g * 7 / 8 + (r + b) / 16;
+ new_b = new_b * 7 / 8 + (r + g ) / 16;
+
+
+ new_r = new_r * (224 - 32) / 255 + 32;
+ new_g = new_g * (220 - 36) / 255 + 36;
+ new_b = new_b * (216 - 40) / 255 + 40;
+ }
+ else if (gb->color_correction_mode == GB_COLOR_CORRECTION_PRESERVE_BRIGHTNESS) {
+ uint8_t old_max = MAX(r, MAX(g, b));
+ uint8_t new_max = MAX(new_r, MAX(new_g, new_b));
+
+ if (new_max != 0) {
+ new_r = new_r * old_max / new_max;
+ new_g = new_g * old_max / new_max;
+ new_b = new_b * old_max / new_max;
+ }
+
+ uint8_t old_min = MIN(r, MIN(g, b));
+ uint8_t new_min = MIN(new_r, MIN(new_g, new_b));
+
+ if (new_min != 0xff) {
+ new_r = 0xff - (0xff - new_r) * (0xff - old_min) / (0xff - new_min);
+ new_g = 0xff - (0xff - new_g) * (0xff - old_min) / (0xff - new_min);
+ new_b = 0xff - (0xff - new_b) * (0xff - old_min) / (0xff - new_min);
+ }
+ }
+ r = new_r;
+ g = new_g;
+ b = new_b;
+ }
+ }
+
+ return gb->rgb_encode_callback(gb, r, g, b);
+}
+
+void GB_palette_changed(GB_gameboy_t *gb, bool background_palette, uint8_t index)
+{
+ if (!gb->rgb_encode_callback || !GB_is_cgb(gb)) return;
+ uint8_t *palette_data = background_palette? gb->background_palettes_data : gb->sprite_palettes_data;
+ uint16_t color = palette_data[index & ~1] | (palette_data[index | 1] << 8);
+
+ (background_palette? gb->background_palettes_rgb : gb->sprite_palettes_rgb)[index / 2] = GB_convert_rgb15(gb, color, false);
+}
+
+void GB_set_color_correction_mode(GB_gameboy_t *gb, GB_color_correction_mode_t mode)
+{
+ gb->color_correction_mode = mode;
+ if (GB_is_cgb(gb)) {
+ for (unsigned i = 0; i < 32; i++) {
+ GB_palette_changed(gb, false, i * 2);
+ GB_palette_changed(gb, true, i * 2);
+ }
+ }
+}
+
+/*
+ STAT interrupt is implemented based on this finding:
+ http://board.byuu.org/phpbb3/viewtopic.php?p=25527#p25531
+
+ General timing is based on GiiBiiAdvance's documents:
+ https://github.com/AntonioND/giibiiadvance
+
+ */
+
+void GB_STAT_update(GB_gameboy_t *gb)
+{
+ if (!(gb->io_registers[GB_IO_LCDC] & 0x80)) return;
+
+ bool previous_interrupt_line = gb->stat_interrupt_line;
+ /* Set LY=LYC bit */
+ /* TODO: This behavior might not be correct for CGB revisions other than C and E */
+ if (gb->ly_for_comparison != (uint16_t)-1 || gb->model <= GB_MODEL_CGB_C) {
+ if (gb->ly_for_comparison == gb->io_registers[GB_IO_LYC]) {
+ gb->lyc_interrupt_line = true;
+ gb->io_registers[GB_IO_STAT] |= 4;
+ }
+ else {
+ if (gb->ly_for_comparison != (uint16_t)-1) {
+ gb->lyc_interrupt_line = false;
+ }
+ gb->io_registers[GB_IO_STAT] &= ~4;
+ }
+ }
+
+ switch (gb->mode_for_interrupt) {
+ case 0: gb->stat_interrupt_line = gb->io_registers[GB_IO_STAT] & 8; break;
+ case 1: gb->stat_interrupt_line = gb->io_registers[GB_IO_STAT] & 0x10; break;
+ case 2: gb->stat_interrupt_line = gb->io_registers[GB_IO_STAT] & 0x20; break;
+ default: gb->stat_interrupt_line = false;
+ }
+
+ /* User requested a LY=LYC interrupt and the LY=LYC bit is on */
+ if ((gb->io_registers[GB_IO_STAT] & 0x40) && gb->lyc_interrupt_line) {
+ gb->stat_interrupt_line = true;
+ }
+
+ if (gb->stat_interrupt_line && !previous_interrupt_line) {
+ gb->io_registers[GB_IO_IF] |= 2;
+ }
+}
+
+void GB_lcd_off(GB_gameboy_t *gb)
+{
+ gb->display_state = 0;
+ gb->display_cycles = 0;
+ /* When the LCD is disabled, state is constant */
+
+ /* When the LCD is off, LY is 0 and STAT mode is 0. */
+ gb->io_registers[GB_IO_LY] = 0;
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ if (gb->hdma_on_hblank) {
+ gb->hdma_on_hblank = false;
+ gb->hdma_on = false;
+
+ /* Todo: is this correct? */
+ gb->hdma_steps_left = 0xff;
+ }
+
+ gb->oam_read_blocked = false;
+ gb->vram_read_blocked = false;
+ gb->oam_write_blocked = false;
+ gb->vram_write_blocked = false;
+ gb->cgb_palettes_blocked = false;
+
+ gb->current_line = 0;
+ gb->ly_for_comparison = 0;
+
+ gb->accessed_oam_row = -1;
+ gb->wy_triggered = false;
+}
+
+static void add_object_from_index(GB_gameboy_t *gb, unsigned index)
+{
+ if (gb->n_visible_objs == 10) return;
+
+ /* TODO: It appears that DMA blocks PPU access to OAM, but it needs verification. */
+ if (gb->dma_steps_left && (gb->dma_cycles >= 0 || gb->is_dma_restarting)) {
+ return;
+ }
+
+ if (gb->oam_ppu_blocked) {
+ return;
+ }
+
+ /* This reverse sorts the visible objects by location and priority */
+ GB_object_t *objects = (GB_object_t *) &gb->oam;
+ bool height_16 = (gb->io_registers[GB_IO_LCDC] & 4) != 0;
+ signed y = objects[index].y - 16;
+ if (y <= gb->current_line && y + (height_16? 16 : 8) > gb->current_line) {
+ unsigned j = 0;
+ for (; j < gb->n_visible_objs; j++) {
+ if (gb->obj_comparators[j] <= objects[index].x) break;
+ }
+ memmove(gb->visible_objs + j + 1, gb->visible_objs + j, gb->n_visible_objs - j);
+ memmove(gb->obj_comparators + j + 1, gb->obj_comparators + j, gb->n_visible_objs - j);
+ gb->visible_objs[j] = index;
+ gb->obj_comparators[j] = objects[index].x;
+ gb->n_visible_objs++;
+ }
+}
+
+static void render_pixel_if_possible(GB_gameboy_t *gb)
+{
+ GB_fifo_item_t *fifo_item = NULL;
+ GB_fifo_item_t *oam_fifo_item = NULL;
+ bool draw_oam = false;
+ bool bg_enabled = true, bg_priority = false;
+
+ if (fifo_size(&gb->bg_fifo)) {
+ fifo_item = fifo_pop(&gb->bg_fifo);
+ bg_priority = fifo_item->bg_priority;
+
+ if (fifo_size(&gb->oam_fifo)) {
+ oam_fifo_item = fifo_pop(&gb->oam_fifo);
+ if (oam_fifo_item->pixel && (gb->io_registers[GB_IO_LCDC] & 2)) {
+ draw_oam = true;
+ bg_priority |= oam_fifo_item->bg_priority;
+ }
+ }
+ }
+
+
+ if (!fifo_item) return;
+
+ /* Drop pixels for scrollings */
+ if (gb->position_in_line >= 160 || (gb->disable_rendering && !gb->sgb)) {
+ gb->position_in_line++;
+ return;
+ }
+
+ /* Mixing */
+
+ if ((gb->io_registers[GB_IO_LCDC] & 0x1) == 0) {
+ if (gb->cgb_mode) {
+ bg_priority = false;
+ }
+ else {
+ bg_enabled = false;
+ }
+ }
+
+ uint8_t icd_pixel = 0;
+ uint32_t *dest = NULL;
+ if (!gb->sgb) {
+ if (gb->border_mode != GB_BORDER_ALWAYS) {
+ dest = gb->screen + gb->lcd_x + gb->current_line * WIDTH;
+ }
+ else {
+ dest = gb->screen + gb->lcd_x + gb->current_line * BORDERED_WIDTH + (BORDERED_WIDTH - WIDTH) / 2 + (BORDERED_HEIGHT - LINES) / 2 * BORDERED_WIDTH;
+ }
+ }
+
+ {
+ uint8_t pixel = bg_enabled? fifo_item->pixel : 0;
+ if (pixel && bg_priority) {
+ draw_oam = false;
+ }
+ if (!gb->cgb_mode) {
+ pixel = ((gb->io_registers[GB_IO_BGP] >> (pixel << 1)) & 3);
+ }
+ if (gb->sgb) {
+ if (gb->current_lcd_line < LINES) {
+ gb->sgb->screen_buffer[gb->lcd_x + gb->current_lcd_line * WIDTH] = gb->stopped? 0 : pixel;
+ }
+ }
+ else if (gb->model & GB_MODEL_NO_SFC_BIT) {
+ if (gb->icd_pixel_callback) {
+ icd_pixel = pixel;
+ }
+ }
+ else if (gb->cgb_palettes_ppu_blocked) {
+ *dest = gb->rgb_encode_callback(gb, 0, 0, 0);
+ }
+ else {
+ *dest = gb->background_palettes_rgb[fifo_item->palette * 4 + pixel];
+ }
+ }
+
+ if (draw_oam) {
+ uint8_t pixel = oam_fifo_item->pixel;
+ if (!gb->cgb_mode) {
+ /* Todo: Verify access timings */
+ pixel = ((gb->io_registers[oam_fifo_item->palette? GB_IO_OBP1 : GB_IO_OBP0] >> (pixel << 1)) & 3);
+ }
+ if (gb->sgb) {
+ if (gb->current_lcd_line < LINES) {
+ gb->sgb->screen_buffer[gb->lcd_x + gb->current_lcd_line * WIDTH] = gb->stopped? 0 : pixel;
+ }
+ }
+ else if (gb->model & GB_MODEL_NO_SFC_BIT) {
+ if (gb->icd_pixel_callback) {
+ icd_pixel = pixel;
+ //gb->icd_pixel_callback(gb, pixel);
+ }
+ }
+ else if (gb->cgb_palettes_ppu_blocked) {
+ *dest = gb->rgb_encode_callback(gb, 0, 0, 0);
+ }
+ else {
+ *dest = gb->sprite_palettes_rgb[oam_fifo_item->palette * 4 + pixel];
+ }
+ }
+
+ if (gb->model & GB_MODEL_NO_SFC_BIT) {
+ if (gb->icd_pixel_callback) {
+ gb->icd_pixel_callback(gb, icd_pixel);
+ }
+ }
+
+ gb->position_in_line++;
+ gb->lcd_x++;
+ gb->window_is_being_fetched = false;
+}
+
+/* All verified CGB timings are based on CGB CPU E. CGB CPUs >= D are known to have
+ slightly different timings than CPUs <= C.
+
+ Todo: Add support to CPU C and older */
+
+static inline uint8_t fetcher_y(GB_gameboy_t *gb)
+{
+ return gb->wx_triggered? gb->window_y : gb->current_line + gb->io_registers[GB_IO_SCY];
+}
+
+static void advance_fetcher_state_machine(GB_gameboy_t *gb)
+{
+ typedef enum {
+ GB_FETCHER_GET_TILE,
+ GB_FETCHER_GET_TILE_DATA_LOWER,
+ GB_FETCHER_GET_TILE_DATA_HIGH,
+ GB_FETCHER_PUSH,
+ GB_FETCHER_SLEEP,
+ } fetcher_step_t;
+
+ fetcher_step_t fetcher_state_machine [8] = {
+ GB_FETCHER_SLEEP,
+ GB_FETCHER_GET_TILE,
+ GB_FETCHER_SLEEP,
+ GB_FETCHER_GET_TILE_DATA_LOWER,
+ GB_FETCHER_SLEEP,
+ GB_FETCHER_GET_TILE_DATA_HIGH,
+ GB_FETCHER_PUSH,
+ GB_FETCHER_PUSH,
+ };
+ switch (fetcher_state_machine[gb->fetcher_state & 7]) {
+ case GB_FETCHER_GET_TILE: {
+ uint16_t map = 0x1800;
+
+ if (!(gb->io_registers[GB_IO_LCDC] & 0x20)) {
+ gb->wx_triggered = false;
+ gb->wx166_glitch = false;
+ }
+
+ /* Todo: Verified for DMG (Tested: SGB2), CGB timing is wrong. */
+ if (gb->io_registers[GB_IO_LCDC] & 0x08 && !gb->wx_triggered) {
+ map = 0x1C00;
+ }
+ else if (gb->io_registers[GB_IO_LCDC] & 0x40 && gb->wx_triggered) {
+ map = 0x1C00;
+ }
+
+ /* Todo: Verified for DMG (Tested: SGB2), CGB timing is wrong. */
+ uint8_t y = fetcher_y(gb);
+ uint8_t x = 0;
+ if (gb->wx_triggered) {
+ x = gb->window_tile_x;
+ }
+ else {
+ x = ((gb->io_registers[GB_IO_SCX] / 8) + gb->fetcher_x) & 0x1F;
+ }
+ if (gb->model > GB_MODEL_CGB_C) {
+ /* This value is cached on the CGB-D and newer, so it cannot be used to mix tiles together */
+ gb->fetcher_y = y;
+ }
+ gb->last_tile_index_address = map + x + y / 8 * 32;
+ gb->current_tile = gb->vram[gb->last_tile_index_address];
+ if (gb->vram_ppu_blocked) {
+ gb->current_tile = 0xFF;
+ }
+ if (GB_is_cgb(gb)) {
+ /* The CGB actually accesses both the tile index AND the attributes in the same T-cycle.
+ This probably means the CGB has a 16-bit data bus for the VRAM. */
+ gb->current_tile_attributes = gb->vram[gb->last_tile_index_address + 0x2000];
+ if (gb->vram_ppu_blocked) {
+ gb->current_tile_attributes = 0xFF;
+ }
+ }
+ }
+ gb->fetcher_state++;
+ break;
+
+ case GB_FETCHER_GET_TILE_DATA_LOWER: {
+ uint8_t y_flip = 0;
+ uint16_t tile_address = 0;
+ uint8_t y = gb->model > GB_MODEL_CGB_C ? gb->fetcher_y : fetcher_y(gb);
+
+ /* Todo: Verified for DMG (Tested: SGB2), CGB timing is wrong. */
+ if (gb->io_registers[GB_IO_LCDC] & 0x10) {
+ tile_address = gb->current_tile * 0x10;
+ }
+ else {
+ tile_address = (int8_t)gb->current_tile * 0x10 + 0x1000;
+ }
+ if (gb->current_tile_attributes & 8) {
+ tile_address += 0x2000;
+ }
+ if (gb->current_tile_attributes & 0x40) {
+ y_flip = 0x7;
+ }
+ gb->current_tile_data[0] =
+ gb->vram[tile_address + ((y & 7) ^ y_flip) * 2];
+ if (gb->vram_ppu_blocked) {
+ gb->current_tile_data[0] = 0xFF;
+ }
+ }
+ gb->fetcher_state++;
+ break;
+
+ case GB_FETCHER_GET_TILE_DATA_HIGH: {
+ /* Todo: Verified for DMG (Tested: SGB2), CGB timing is wrong.
+ Additionally, on CGB-D and newer mixing two tiles by changing the tileset
+ bit mid-fetching causes a glitched mixing of the two, in comparison to the
+ more logical DMG version. */
+ uint16_t tile_address = 0;
+ uint8_t y = gb->model > GB_MODEL_CGB_C ? gb->fetcher_y : fetcher_y(gb);
+
+ if (gb->io_registers[GB_IO_LCDC] & 0x10) {
+ tile_address = gb->current_tile * 0x10;
+ }
+ else {
+ tile_address = (int8_t)gb->current_tile * 0x10 + 0x1000;
+ }
+ if (gb->current_tile_attributes & 8) {
+ tile_address += 0x2000;
+ }
+ uint8_t y_flip = 0;
+ if (gb->current_tile_attributes & 0x40) {
+ y_flip = 0x7;
+ }
+ gb->last_tile_data_address = tile_address + ((y & 7) ^ y_flip) * 2 + 1;
+ gb->current_tile_data[1] =
+ gb->vram[gb->last_tile_data_address];
+ if (gb->vram_ppu_blocked) {
+ gb->current_tile_data[1] = 0xFF;
+ }
+ }
+ if (gb->wx_triggered) {
+ gb->window_tile_x++;
+ gb->window_tile_x &= 0x1f;
+ }
+
+ // fallthrough
+ case GB_FETCHER_PUSH: {
+ if (gb->fetcher_state == 6) {
+ /* The background map index increase at this specific point. If this state is not reached,
+ it will simply not increase. */
+ gb->fetcher_x++;
+ gb->fetcher_x &= 0x1f;
+ }
+ if (gb->fetcher_state < 7) {
+ gb->fetcher_state++;
+ }
+ if (fifo_size(&gb->bg_fifo) > 0) break;
+
+ fifo_push_bg_row(&gb->bg_fifo, gb->current_tile_data[0], gb->current_tile_data[1],
+ gb->current_tile_attributes & 7, gb->current_tile_attributes & 0x80, gb->current_tile_attributes & 0x20);
+ gb->fetcher_state = 0;
+ }
+ break;
+
+ case GB_FETCHER_SLEEP:
+ {
+ gb->fetcher_state++;
+ }
+ break;
+ }
+}
+
+static uint16_t get_object_line_address(GB_gameboy_t *gb, const GB_object_t *object)
+{
+ /* TODO: what does the PPU read if DMA is active? */
+ if (gb->oam_ppu_blocked) {
+ static const GB_object_t blocked = {0xFF, 0xFF, 0xFF, 0xFF};
+ object = &blocked;
+ }
+
+ bool height_16 = (gb->io_registers[GB_IO_LCDC] & 4) != 0; /* Todo: Which T-cycle actually reads this? */
+ uint8_t tile_y = (gb->current_line - object->y) & (height_16? 0xF : 7);
+
+ if (object->flags & 0x40) { /* Flip Y */
+ tile_y ^= height_16? 0xF : 7;
+ }
+
+ /* Todo: I'm not 100% sure an access to OAM can't trigger the OAM bug while we're accessing this */
+ uint16_t line_address = (height_16? object->tile & 0xFE : object->tile) * 0x10 + tile_y * 2;
+
+ if (gb->cgb_mode && (object->flags & 0x8)) { /* Use VRAM bank 2 */
+ line_address += 0x2000;
+ }
+ return line_address;
+}
+
+/*
+ TODO: It seems that the STAT register's mode bits are always "late" by 4 T-cycles.
+ The PPU logic can be greatly simplified if that delay is simply emulated.
+ */
+void GB_display_run(GB_gameboy_t *gb, uint8_t cycles)
+{
+ /* The PPU does not advance while in STOP mode on the DMG */
+ if (gb->stopped && !GB_is_cgb(gb)) {
+ gb->cycles_in_stop_mode += cycles;
+ if (gb->cycles_in_stop_mode >= LCDC_PERIOD) {
+ gb->cycles_in_stop_mode -= LCDC_PERIOD;
+ display_vblank(gb);
+ }
+ return;
+ }
+ GB_object_t *objects = (GB_object_t *) &gb->oam;
+
+ GB_STATE_MACHINE(gb, display, cycles, 2) {
+ GB_STATE(gb, display, 1);
+ GB_STATE(gb, display, 2);
+ // GB_STATE(gb, display, 3);
+ // GB_STATE(gb, display, 4);
+ // GB_STATE(gb, display, 5);
+ GB_STATE(gb, display, 6);
+ GB_STATE(gb, display, 7);
+ GB_STATE(gb, display, 8);
+ // GB_STATE(gb, display, 9);
+ GB_STATE(gb, display, 10);
+ GB_STATE(gb, display, 11);
+ GB_STATE(gb, display, 12);
+ GB_STATE(gb, display, 13);
+ GB_STATE(gb, display, 14);
+ GB_STATE(gb, display, 15);
+ GB_STATE(gb, display, 16);
+ GB_STATE(gb, display, 17);
+ // GB_STATE(gb, display, 19);
+ GB_STATE(gb, display, 20);
+ GB_STATE(gb, display, 21);
+ GB_STATE(gb, display, 22);
+ GB_STATE(gb, display, 23);
+ // GB_STATE(gb, display, 24);
+ GB_STATE(gb, display, 25);
+ GB_STATE(gb, display, 26);
+ GB_STATE(gb, display, 27);
+ GB_STATE(gb, display, 28);
+ GB_STATE(gb, display, 29);
+ GB_STATE(gb, display, 30);
+ // GB_STATE(gb, display, 31);
+ GB_STATE(gb, display, 32);
+ GB_STATE(gb, display, 33);
+ GB_STATE(gb, display, 34);
+ GB_STATE(gb, display, 35);
+ GB_STATE(gb, display, 36);
+ GB_STATE(gb, display, 37);
+ GB_STATE(gb, display, 38);
+ GB_STATE(gb, display, 39);
+ GB_STATE(gb, display, 40);
+ GB_STATE(gb, display, 41);
+ GB_STATE(gb, display, 42);
+ }
+
+ if (!(gb->io_registers[GB_IO_LCDC] & 0x80)) {
+ while (true) {
+ GB_SLEEP(gb, display, 1, LCDC_PERIOD);
+ display_vblank(gb);
+ gb->cgb_repeated_a_frame = true;
+ }
+ return;
+ }
+
+ gb->is_odd_frame = false;
+
+ if (!GB_is_cgb(gb)) {
+ GB_SLEEP(gb, display, 23, 1);
+ }
+
+ /* Handle mode 2 on the very first line 0 */
+ gb->current_line = 0;
+ gb->window_y = -1;
+ /* Todo: verify timings */
+ if (gb->io_registers[GB_IO_WY] == 0) {
+ gb->wy_triggered = true;
+ }
+ else {
+ gb->wy_triggered = false;
+ }
+
+ gb->ly_for_comparison = 0;
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ gb->mode_for_interrupt = -1;
+ gb->oam_read_blocked = false;
+ gb->vram_read_blocked = false;
+ gb->oam_write_blocked = false;
+ gb->vram_write_blocked = false;
+ gb->cgb_palettes_blocked = false;
+ gb->cycles_for_line = MODE2_LENGTH - 4;
+ GB_STAT_update(gb);
+ GB_SLEEP(gb, display, 2, MODE2_LENGTH - 4);
+
+ gb->oam_write_blocked = true;
+ gb->cycles_for_line += 2;
+ GB_STAT_update(gb);
+ GB_SLEEP(gb, display, 34, 2);
+
+ gb->n_visible_objs = 0;
+ gb->cycles_for_line += 8; // Mode 0 is shorter on the first line 0, so we augment cycles_for_line by 8 extra cycles.
+
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ gb->io_registers[GB_IO_STAT] |= 3;
+ gb->mode_for_interrupt = 3;
+
+ gb->oam_write_blocked = true;
+ gb->oam_read_blocked = true;
+ gb->vram_read_blocked = gb->cgb_double_speed;
+ gb->vram_write_blocked = gb->cgb_double_speed;
+ if (!GB_is_cgb(gb)) {
+ gb->vram_read_blocked = true;
+ gb->vram_write_blocked = true;
+ }
+ gb->cycles_for_line += 2;
+ GB_SLEEP(gb, display, 37, 2);
+
+ gb->cgb_palettes_blocked = true;
+ gb->cycles_for_line += (GB_is_cgb(gb) && gb->model <= GB_MODEL_CGB_C)? 2 : 3;
+ GB_SLEEP(gb, display, 38, (GB_is_cgb(gb) && gb->model <= GB_MODEL_CGB_C)? 2 : 3);
+
+ gb->vram_read_blocked = true;
+ gb->vram_write_blocked = true;
+ gb->wx_triggered = false;
+ gb->wx166_glitch = false;
+ goto mode_3_start;
+
+ while (true) {
+ /* Lines 0 - 143 */
+ gb->window_y = -1;
+ for (; gb->current_line < LINES; gb->current_line++) {
+ /* Todo: verify timings */
+ if ((gb->io_registers[GB_IO_WY] == gb->current_line ||
+ (gb->current_line != 0 && gb->io_registers[GB_IO_WY] == gb->current_line - 1))) {
+ gb->wy_triggered = true;
+ }
+
+ gb->oam_write_blocked = GB_is_cgb(gb) && !gb->cgb_double_speed;
+ gb->accessed_oam_row = 0;
+
+ GB_SLEEP(gb, display, 35, 2);
+ gb->oam_write_blocked = GB_is_cgb(gb);
+
+ GB_SLEEP(gb, display, 6, 1);
+ gb->io_registers[GB_IO_LY] = gb->current_line;
+ gb->oam_read_blocked = true;
+ gb->ly_for_comparison = gb->current_line? -1 : 0;
+
+ /* The OAM STAT interrupt occurs 1 T-cycle before STAT actually changes, except on line 0.
+ PPU glitch? */
+ if (gb->current_line != 0) {
+ gb->mode_for_interrupt = 2;
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ }
+ else if (!GB_is_cgb(gb)) {
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ }
+ GB_STAT_update(gb);
+
+ GB_SLEEP(gb, display, 7, 1);
+
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ gb->io_registers[GB_IO_STAT] |= 2;
+ gb->mode_for_interrupt = 2;
+ gb->oam_write_blocked = true;
+ gb->ly_for_comparison = gb->current_line;
+ GB_STAT_update(gb);
+ gb->mode_for_interrupt = -1;
+ GB_STAT_update(gb);
+ gb->n_visible_objs = 0;
+
+ for (gb->oam_search_index = 0; gb->oam_search_index < 40; gb->oam_search_index++) {
+ if (GB_is_cgb(gb)) {
+ add_object_from_index(gb, gb->oam_search_index);
+ /* The CGB does not care about the accessed OAM row as there's no OAM bug */
+ }
+ GB_SLEEP(gb, display, 8, 2);
+ if (!GB_is_cgb(gb)) {
+ add_object_from_index(gb, gb->oam_search_index);
+ gb->accessed_oam_row = (gb->oam_search_index & ~1) * 4 + 8;
+ }
+ if (gb->oam_search_index == 37) {
+ gb->vram_read_blocked = !GB_is_cgb(gb);
+ gb->vram_write_blocked = false;
+ gb->cgb_palettes_blocked = false;
+ gb->oam_write_blocked = GB_is_cgb(gb);
+ GB_STAT_update(gb);
+ }
+ }
+ gb->cycles_for_line = MODE2_LENGTH + 4;
+
+ gb->accessed_oam_row = -1;
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ gb->io_registers[GB_IO_STAT] |= 3;
+ gb->mode_for_interrupt = 3;
+ gb->vram_read_blocked = true;
+ gb->vram_write_blocked = true;
+ gb->cgb_palettes_blocked = false;
+ gb->oam_write_blocked = true;
+ gb->oam_read_blocked = true;
+
+ GB_STAT_update(gb);
+
+
+ uint8_t idle_cycles = 3;
+ if (GB_is_cgb(gb) && gb->model <= GB_MODEL_CGB_C) {
+ idle_cycles = 2;
+ }
+ gb->cycles_for_line += idle_cycles;
+ GB_SLEEP(gb, display, 10, idle_cycles);
+
+ gb->cgb_palettes_blocked = true;
+ gb->cycles_for_line += 2;
+ GB_SLEEP(gb, display, 32, 2);
+ mode_3_start:
+
+ fifo_clear(&gb->bg_fifo);
+ fifo_clear(&gb->oam_fifo);
+ /* Fill the FIFO with 8 pixels of "junk", it's going to be dropped anyway. */
+ fifo_push_bg_row(&gb->bg_fifo, 0, 0, 0, false, false);
+ /* Todo: find out actual access time of SCX */
+ gb->position_in_line = - (gb->io_registers[GB_IO_SCX] & 7) - 8;
+ gb->lcd_x = 0;
+
+ gb->fetcher_x = 0;
+ gb->extra_penalty_for_sprite_at_0 = (gb->io_registers[GB_IO_SCX] & 7);
+
+
+ /* The actual rendering cycle */
+ gb->fetcher_state = 0;
+ while (true) {
+ /* Handle window */
+ /* TODO: It appears that WX checks if the window begins *next* pixel, not *this* pixel. For this reason,
+ WX=167 has no effect at all (It checks if the PPU X position is 161, which never happens) and WX=166
+ has weird artifacts (It appears to activate the window during HBlank, as PPU X is temporarily 160 at
+ that point. The code should be updated to represent this, and this will fix the time travel hack in
+ WX's access conflict code. */
+
+ if (!gb->wx_triggered && gb->wy_triggered && (gb->io_registers[GB_IO_LCDC] & 0x20)) {
+ bool should_activate_window = false;
+ if (gb->io_registers[GB_IO_WX] == 0) {
+ static const uint8_t scx_to_wx0_comparisons[] = {-7, -9, -10, -11, -12, -13, -14, -14};
+ if (gb->position_in_line == scx_to_wx0_comparisons[gb->io_registers[GB_IO_SCX] & 7]) {
+ should_activate_window = true;
+ }
+ }
+ else if (gb->wx166_glitch) {
+ static const uint8_t scx_to_wx166_comparisons[] = {-8, -9, -10, -11, -12, -13, -14, -15};
+ if (gb->position_in_line == scx_to_wx166_comparisons[gb->io_registers[GB_IO_SCX] & 7]) {
+ should_activate_window = true;
+ }
+ }
+ else if (gb->io_registers[GB_IO_WX] < 166 + GB_is_cgb(gb)) {
+ if (gb->io_registers[GB_IO_WX] == (uint8_t) (gb->position_in_line + 7)) {
+ should_activate_window = true;
+ }
+ else if (gb->io_registers[GB_IO_WX] == (uint8_t) (gb->position_in_line + 6) && !gb->wx_just_changed) {
+ should_activate_window = true;
+ /* LCD-PPU horizontal desync! It only appears to happen on DMGs, but not all of them.
+ This doesn't seem to be CPU revision dependent, but most revisions */
+ if ((gb->model & GB_MODEL_FAMILY_MASK) == GB_MODEL_DMG_FAMILY && !GB_is_sgb(gb)) {
+ if (gb->lcd_x > 0) {
+ gb->lcd_x--;
+ }
+ }
+ }
+ }
+
+ if (should_activate_window) {
+ gb->window_y++;
+ /* TODO: Verify fetcher access timings in this case */
+ if (gb->io_registers[GB_IO_WX] == 0 && (gb->io_registers[GB_IO_SCX] & 7)) {
+ gb->cycles_for_line++;
+ GB_SLEEP(gb, display, 42, 1);
+ }
+ gb->wx_triggered = true;
+ gb->window_tile_x = 0;
+ fifo_clear(&gb->bg_fifo);
+ gb->fetcher_state = 0;
+ gb->window_is_being_fetched = true;
+ }
+ else if (!GB_is_cgb(gb) && gb->io_registers[GB_IO_WX] == 166 && gb->io_registers[GB_IO_WX] == (uint8_t) (gb->position_in_line + 7)) {
+ gb->window_y++;
+ }
+ }
+
+ /* TODO: What happens when WX=0? */
+ if (!GB_is_cgb(gb) && gb->wx_triggered && !gb->window_is_being_fetched &&
+ gb->fetcher_state == 0 && gb->io_registers[GB_IO_WX] == (uint8_t) (gb->position_in_line + 7) ) {
+ // Insert a pixel right at the FIFO's end
+ gb->bg_fifo.read_end--;
+ gb->bg_fifo.read_end &= GB_FIFO_LENGTH - 1;
+ gb->bg_fifo.fifo[gb->bg_fifo.read_end] = (GB_fifo_item_t){0,};
+ gb->window_is_being_fetched = false;
+ }
+
+ /* Handle objects */
+ /* When the sprite enabled bit is off, this proccess is skipped entirely on the DMG, but not on the CGB.
+ On the CGB, this bit is checked only when the pixel is actually popped from the FIFO. */
+
+ while (gb->n_visible_objs != 0 &&
+ (gb->position_in_line < 160 || gb->position_in_line >= (uint8_t)(-8)) &&
+ gb->obj_comparators[gb->n_visible_objs - 1] < (uint8_t)(gb->position_in_line + 8)) {
+ gb->n_visible_objs--;
+ }
+
+ gb->during_object_fetch = true;
+ while (gb->n_visible_objs != 0 &&
+ (gb->io_registers[GB_IO_LCDC] & 2 || GB_is_cgb(gb)) &&
+ gb->obj_comparators[gb->n_visible_objs - 1] == (uint8_t)(gb->position_in_line + 8)) {
+
+ while (gb->fetcher_state < 5 || fifo_size(&gb->bg_fifo) == 0) {
+ advance_fetcher_state_machine(gb);
+ gb->cycles_for_line++;
+ GB_SLEEP(gb, display, 27, 1);
+ if (gb->object_fetch_aborted) {
+ goto abort_fetching_object;
+ }
+ }
+
+ /* Todo: Measure if penalty occurs before or after waiting for the fetcher. */
+ if (gb->extra_penalty_for_sprite_at_0 != 0) {
+ if (gb->obj_comparators[gb->n_visible_objs - 1] == 0) {
+ gb->cycles_for_line += gb->extra_penalty_for_sprite_at_0;
+ GB_SLEEP(gb, display, 28, gb->extra_penalty_for_sprite_at_0);
+ gb->extra_penalty_for_sprite_at_0 = 0;
+ if (gb->object_fetch_aborted) {
+ goto abort_fetching_object;
+ }
+ }
+ }
+
+ /* TODO: Can this be deleted? { */
+ advance_fetcher_state_machine(gb);
+ gb->cycles_for_line++;
+ GB_SLEEP(gb, display, 41, 1);
+ if (gb->object_fetch_aborted) {
+ goto abort_fetching_object;
+ }
+ /* } */
+
+ advance_fetcher_state_machine(gb);
+
+ gb->cycles_for_line += 3;
+ GB_SLEEP(gb, display, 20, 3);
+ if (gb->object_fetch_aborted) {
+ goto abort_fetching_object;
+ }
+
+ gb->object_low_line_address = get_object_line_address(gb, &objects[gb->visible_objs[gb->n_visible_objs - 1]]);
+
+ gb->cycles_for_line++;
+ GB_SLEEP(gb, display, 39, 1);
+ if (gb->object_fetch_aborted) {
+ goto abort_fetching_object;
+ }
+
+ gb->during_object_fetch = false;
+ gb->cycles_for_line++;
+ GB_SLEEP(gb, display, 40, 1);
+
+ const GB_object_t *object = &objects[gb->visible_objs[gb->n_visible_objs - 1]];
+
+ uint16_t line_address = get_object_line_address(gb, object);
+
+ uint8_t palette = (object->flags & 0x10) ? 1 : 0;
+ if (gb->cgb_mode) {
+ palette = object->flags & 0x7;
+ }
+ fifo_overlay_object_row(&gb->oam_fifo,
+ gb->vram_ppu_blocked? 0xFF : gb->vram[gb->object_low_line_address],
+ gb->vram_ppu_blocked? 0xFF : gb->vram[line_address + 1],
+ palette,
+ object->flags & 0x80,
+ gb->object_priority == GB_OBJECT_PRIORITY_INDEX? gb->visible_objs[gb->n_visible_objs - 1] : 0,
+ object->flags & 0x20);
+
+ gb->n_visible_objs--;
+ }
+
+abort_fetching_object:
+ gb->object_fetch_aborted = false;
+ gb->during_object_fetch = false;
+
+ render_pixel_if_possible(gb);
+ advance_fetcher_state_machine(gb);
+
+ if (gb->position_in_line == 160) break;
+ gb->cycles_for_line++;
+ GB_SLEEP(gb, display, 21, 1);
+ }
+
+ while (gb->lcd_x != 160 && !gb->disable_rendering && gb->screen && !gb->sgb) {
+ /* Oh no! The PPU and LCD desynced! Fill the rest of the line whith white. */
+ uint32_t *dest = NULL;
+ if (gb->border_mode != GB_BORDER_ALWAYS) {
+ dest = gb->screen + gb->lcd_x + gb->current_line * WIDTH;
+ }
+ else {
+ dest = gb->screen + gb->lcd_x + gb->current_line * BORDERED_WIDTH + (BORDERED_WIDTH - WIDTH) / 2 + (BORDERED_HEIGHT - LINES) / 2 * BORDERED_WIDTH;
+ }
+ *dest = gb->background_palettes_rgb[0];
+ gb->lcd_x++;
+
+ }
+
+ /* TODO: Verify timing */
+ if (!GB_is_cgb(gb) && gb->wy_triggered && (gb->io_registers[GB_IO_LCDC] & 0x20) && gb->io_registers[GB_IO_WX] == 166) {
+ gb->wx166_glitch = true;
+ }
+ else {
+ gb->wx166_glitch = false;
+ }
+ gb->wx_triggered = false;
+
+ if (GB_is_cgb(gb) && gb->model <= GB_MODEL_CGB_C) {
+ gb->cycles_for_line++;
+ GB_SLEEP(gb, display, 30, 1);
+ }
+
+ if (!gb->cgb_double_speed) {
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ gb->mode_for_interrupt = 0;
+ gb->oam_read_blocked = false;
+ gb->vram_read_blocked = false;
+ gb->oam_write_blocked = false;
+ gb->vram_write_blocked = false;
+ }
+
+ gb->cycles_for_line++;
+ GB_SLEEP(gb, display, 22, 1);
+
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ gb->mode_for_interrupt = 0;
+ gb->oam_read_blocked = false;
+ gb->vram_read_blocked = false;
+ gb->oam_write_blocked = false;
+ gb->vram_write_blocked = false;
+ GB_STAT_update(gb);
+
+ /* Todo: Measure this value */
+ gb->cycles_for_line += 2;
+ GB_SLEEP(gb, display, 33, 2);
+ gb->cgb_palettes_blocked = !gb->cgb_double_speed;
+
+ gb->cycles_for_line += 2;
+ GB_SLEEP(gb, display, 36, 2);
+ gb->cgb_palettes_blocked = false;
+
+ gb->cycles_for_line += 8;
+ GB_SLEEP(gb, display, 25, 8);
+
+ if (gb->hdma_on_hblank) {
+ gb->hdma_starting = true;
+ }
+ GB_SLEEP(gb, display, 11, LINE_LENGTH - gb->cycles_for_line);
+ gb->mode_for_interrupt = 2;
+
+ // Todo: unverified timing
+ gb->current_lcd_line++;
+ if (gb->current_lcd_line == LINES && GB_is_sgb(gb)) {
+ display_vblank(gb);
+ }
+
+ if (gb->icd_hreset_callback) {
+ gb->icd_hreset_callback(gb);
+ }
+ }
+ gb->wx166_glitch = false;
+ /* Lines 144 - 152 */
+ for (; gb->current_line < VIRTUAL_LINES - 1; gb->current_line++) {
+ gb->io_registers[GB_IO_LY] = gb->current_line;
+ gb->ly_for_comparison = -1;
+ GB_SLEEP(gb, display, 26, 2);
+ if (gb->current_line == LINES) {
+ gb->mode_for_interrupt = 2;
+ }
+ GB_STAT_update(gb);
+ GB_SLEEP(gb, display, 12, 2);
+ gb->ly_for_comparison = gb->current_line;
+
+ if (gb->current_line == LINES) {
+ /* Entering VBlank state triggers the OAM interrupt */
+ gb->io_registers[GB_IO_STAT] &= ~3;
+ gb->io_registers[GB_IO_STAT] |= 1;
+ gb->io_registers[GB_IO_IF] |= 1;
+ gb->mode_for_interrupt = 2;
+ GB_STAT_update(gb);
+ gb->mode_for_interrupt = 1;
+ GB_STAT_update(gb);
+
+ if (gb->frame_skip_state == GB_FRAMESKIP_LCD_TURNED_ON) {
+ if (GB_is_cgb(gb)) {
+ GB_timing_sync(gb);
+ gb->frame_skip_state = GB_FRAMESKIP_FIRST_FRAME_SKIPPED;
+ }
+ else {
+ if (!GB_is_sgb(gb) || gb->current_lcd_line < LINES) {
+ gb->is_odd_frame ^= true;
+ display_vblank(gb);
+ }
+ gb->frame_skip_state = GB_FRAMESKIP_SECOND_FRAME_RENDERED;
+ }
+ }
+ else {
+ if (!GB_is_sgb(gb) || gb->current_lcd_line < LINES) {
+ gb->is_odd_frame ^= true;
+ display_vblank(gb);
+ }
+ if (gb->frame_skip_state == GB_FRAMESKIP_FIRST_FRAME_SKIPPED) {
+ gb->cgb_repeated_a_frame = true;
+ gb->frame_skip_state = GB_FRAMESKIP_SECOND_FRAME_RENDERED;
+ }
+ else {
+ gb->cgb_repeated_a_frame = false;
+ }
+ }
+ }
+
+ GB_STAT_update(gb);
+ GB_SLEEP(gb, display, 13, LINE_LENGTH - 4);
+ }
+
+ /* TODO: Verified on SGB2 and CGB-E. Actual interrupt timings not tested. */
+ /* Lines 153 */
+ gb->io_registers[GB_IO_LY] = 153;
+ gb->ly_for_comparison = -1;
+ GB_STAT_update(gb);
+ GB_SLEEP(gb, display, 14, (gb->model > GB_MODEL_CGB_C)? 4: 6);
+
+ if (!GB_is_cgb(gb)) {
+ gb->io_registers[GB_IO_LY] = 0;
+ }
+ gb->ly_for_comparison = 153;
+ GB_STAT_update(gb);
+ GB_SLEEP(gb, display, 15, (gb->model > GB_MODEL_CGB_C)? 4: 2);
+
+ gb->io_registers[GB_IO_LY] = 0;
+ gb->ly_for_comparison = (gb->model > GB_MODEL_CGB_C)? 153 : -1;
+ GB_STAT_update(gb);
+ GB_SLEEP(gb, display, 16, 4);
+
+ gb->ly_for_comparison = 0;
+ GB_STAT_update(gb);
+ GB_SLEEP(gb, display, 29, 12); /* Writing to LYC during this period on a CGB has side effects */
+ GB_SLEEP(gb, display, 17, LINE_LENGTH - 24);
+
+
+ gb->current_line = 0;
+ /* Todo: verify timings */
+ if ((gb->io_registers[GB_IO_LCDC] & 0x20) &&
+ (gb->io_registers[GB_IO_WY] == 0)) {
+ gb->wy_triggered = true;
+ }
+ else {
+ gb->wy_triggered = false;
+ }
+
+ // TODO: not the correct timing
+ gb->current_lcd_line = 0;
+ if (gb->icd_vreset_callback) {
+ gb->icd_vreset_callback(gb);
+ }
+ }
+}
+
+void GB_draw_tileset(GB_gameboy_t *gb, uint32_t *dest, GB_palette_type_t palette_type, uint8_t palette_index)
+{
+ uint32_t none_palette[4];
+ uint32_t *palette = NULL;
+
+ switch (GB_is_cgb(gb)? palette_type : GB_PALETTE_NONE) {
+ default:
+ case GB_PALETTE_NONE:
+ none_palette[0] = gb->rgb_encode_callback(gb, 0xFF, 0xFF, 0xFF);
+ none_palette[1] = gb->rgb_encode_callback(gb, 0xAA, 0xAA, 0xAA);
+ none_palette[2] = gb->rgb_encode_callback(gb, 0x55, 0x55, 0x55);
+ none_palette[3] = gb->rgb_encode_callback(gb, 0, 0, 0 );
+ palette = none_palette;
+ break;
+ case GB_PALETTE_BACKGROUND:
+ palette = gb->background_palettes_rgb + (4 * (palette_index & 7));
+ break;
+ case GB_PALETTE_OAM:
+ palette = gb->sprite_palettes_rgb + (4 * (palette_index & 7));
+ break;
+ }
+
+ for (unsigned y = 0; y < 192; y++) {
+ for (unsigned x = 0; x < 256; x++) {
+ if (x >= 128 && !GB_is_cgb(gb)) {
+ *(dest++) = gb->background_palettes_rgb[0];
+ continue;
+ }
+ uint16_t tile = (x % 128) / 8 + y / 8 * 16;
+ uint16_t tile_address = tile * 0x10 + (x >= 128? 0x2000 : 0);
+ uint8_t pixel = (((gb->vram[tile_address + (y & 7) * 2 ] >> ((~x)&7)) & 1 ) |
+ ((gb->vram[tile_address + (y & 7) * 2 + 1] >> ((~x)&7)) & 1) << 1);
+
+ if (!gb->cgb_mode) {
+ if (palette_type == GB_PALETTE_BACKGROUND) {
+ pixel = ((gb->io_registers[GB_IO_BGP] >> (pixel << 1)) & 3);
+ }
+ else if (!gb->cgb_mode) {
+ if (palette_type == GB_PALETTE_OAM) {
+ pixel = ((gb->io_registers[palette_index == 0? GB_IO_OBP0 : GB_IO_OBP1] >> (pixel << 1)) & 3);
+ }
+ }
+ }
+
+
+ *(dest++) = palette[pixel];
+ }
+ }
+}
+
+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)
+{
+ uint32_t none_palette[4];
+ uint32_t *palette = NULL;
+ uint16_t map = 0x1800;
+
+ switch (GB_is_cgb(gb)? palette_type : GB_PALETTE_NONE) {
+ case GB_PALETTE_NONE:
+ none_palette[0] = gb->rgb_encode_callback(gb, 0xFF, 0xFF, 0xFF);
+ none_palette[1] = gb->rgb_encode_callback(gb, 0xAA, 0xAA, 0xAA);
+ none_palette[2] = gb->rgb_encode_callback(gb, 0x55, 0x55, 0x55);
+ none_palette[3] = gb->rgb_encode_callback(gb, 0, 0, 0 );
+ palette = none_palette;
+ break;
+ case GB_PALETTE_BACKGROUND:
+ palette = gb->background_palettes_rgb + (4 * (palette_index & 7));
+ break;
+ case GB_PALETTE_OAM:
+ palette = gb->sprite_palettes_rgb + (4 * (palette_index & 7));
+ break;
+ case GB_PALETTE_AUTO:
+ break;
+ }
+
+ if (map_type == GB_MAP_9C00 || (map_type == GB_MAP_AUTO && gb->io_registers[GB_IO_LCDC] & 0x08)) {
+ map = 0x1c00;
+ }
+
+ if (tileset_type == GB_TILESET_AUTO) {
+ tileset_type = (gb->io_registers[GB_IO_LCDC] & 0x10)? GB_TILESET_8800 : GB_TILESET_8000;
+ }
+
+ for (unsigned y = 0; y < 256; y++) {
+ for (unsigned x = 0; x < 256; x++) {
+ uint8_t tile = gb->vram[map + x/8 + y/8 * 32];
+ uint16_t tile_address;
+ uint8_t attributes = 0;
+
+ if (tileset_type == GB_TILESET_8800) {
+ tile_address = tile * 0x10;
+ }
+ else {
+ tile_address = (int8_t) tile * 0x10 + 0x1000;
+ }
+
+ if (gb->cgb_mode) {
+ attributes = gb->vram[map + x/8 + y/8 * 32 + 0x2000];
+ }
+
+ if (attributes & 0x8) {
+ tile_address += 0x2000;
+ }
+
+ uint8_t pixel = (((gb->vram[tile_address + (((attributes & 0x40)? ~y : y) & 7) * 2 ] >> (((attributes & 0x20)? x : ~x)&7)) & 1 ) |
+ ((gb->vram[tile_address + (((attributes & 0x40)? ~y : y) & 7) * 2 + 1] >> (((attributes & 0x20)? x : ~x)&7)) & 1) << 1);
+
+ if (!gb->cgb_mode && (palette_type == GB_PALETTE_BACKGROUND || palette_type == GB_PALETTE_AUTO)) {
+ pixel = ((gb->io_registers[GB_IO_BGP] >> (pixel << 1)) & 3);
+ }
+
+ if (palette) {
+ *(dest++) = palette[pixel];
+ }
+ else {
+ *(dest++) = gb->background_palettes_rgb[(attributes & 7) * 4 + pixel];
+ }
+ }
+ }
+}
+
+uint8_t GB_get_oam_info(GB_gameboy_t *gb, GB_oam_info_t *dest, uint8_t *sprite_height)
+{
+ uint8_t count = 0;
+ *sprite_height = (gb->io_registers[GB_IO_LCDC] & 4) ? 16:8;
+ uint8_t oam_to_dest_index[40] = {0,};
+ for (unsigned y = 0; y < LINES; y++) {
+ GB_object_t *sprite = (GB_object_t *) &gb->oam;
+ uint8_t sprites_in_line = 0;
+ for (uint8_t i = 0; i < 40; i++, sprite++) {
+ signed sprite_y = sprite->y - 16;
+ bool obscured = false;
+ // Is sprite not in this line?
+ if (sprite_y > y || sprite_y + *sprite_height <= y) continue;
+ if (++sprites_in_line == 11) obscured = true;
+
+ GB_oam_info_t *info = NULL;
+ if (!oam_to_dest_index[i]) {
+ info = dest + count;
+ oam_to_dest_index[i] = ++count;
+ info->x = sprite->x;
+ info->y = sprite->y;
+ info->tile = *sprite_height == 16? sprite->tile & 0xFE : sprite->tile;
+ info->flags = sprite->flags;
+ info->obscured_by_line_limit = false;
+ info->oam_addr = 0xFE00 + i * sizeof(*sprite);
+ }
+ else {
+ info = dest + oam_to_dest_index[i] - 1;
+ }
+ info->obscured_by_line_limit |= obscured;
+ }
+ }
+
+ for (unsigned i = 0; i < count; i++) {
+ uint16_t vram_address = dest[i].tile * 0x10;
+ uint8_t flags = dest[i].flags;
+ uint8_t palette = gb->cgb_mode? (flags & 7) : ((flags & 0x10)? 1 : 0);
+ if (GB_is_cgb(gb) && (flags & 0x8)) {
+ vram_address += 0x2000;
+ }
+
+ for (unsigned y = 0; y < *sprite_height; y++) {
+ UNROLL
+ for (unsigned x = 0; x < 8; x++) {
+ uint8_t color = (((gb->vram[vram_address ] >> ((~x)&7)) & 1 ) |
+ ((gb->vram[vram_address + 1] >> ((~x)&7)) & 1) << 1 );
+
+ if (!gb->cgb_mode) {
+ color = (gb->io_registers[palette? GB_IO_OBP1:GB_IO_OBP0] >> (color << 1)) & 3;
+ }
+ dest[i].image[((flags & 0x20)?7-x:x) + ((flags & 0x40)?*sprite_height - 1 -y:y) * 8] = gb->sprite_palettes_rgb[palette * 4 + color];
+ }
+ vram_address += 2;
+ }
+ }
+ return count;
+}
+
+
+bool GB_is_odd_frame(GB_gameboy_t *gb)
+{
+ return gb->is_odd_frame;
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/display.h b/waterbox/bsnescore/bsnes/gb/Core/display.h
new file mode 100644
index 0000000000..5bdeba8ddc
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/display.h
@@ -0,0 +1,62 @@
+#ifndef display_h
+#define display_h
+
+#include "gb.h"
+#include
+#include
+
+#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_STAT_update(GB_gameboy_t *gb);
+void GB_lcd_off(GB_gameboy_t *gb);
+
+enum {
+ GB_OBJECT_PRIORITY_UNDEFINED, // For save state compatibility
+ GB_OBJECT_PRIORITY_X,
+ GB_OBJECT_PRIORITY_INDEX,
+};
+
+#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_REDUCE_CONTRAST,
+} 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, bool for_border);
+void GB_set_color_correction_mode(GB_gameboy_t *gb, GB_color_correction_mode_t mode);
+bool GB_is_odd_frame(GB_gameboy_t *gb);
+#endif /* display_h */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/gb.c b/waterbox/bsnescore/bsnes/gb/Core/gb.c
new file mode 100644
index 0000000000..7325d79ae0
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/gb.c
@@ -0,0 +1,1619 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#ifndef _WIN32
+#include
+#include
+#endif
+#include "random.h"
+#include "gb.h"
+
+
+#ifdef GB_DISABLE_REWIND
+#define GB_rewind_free(...)
+#define GB_rewind_push(...)
+#endif
+
+
+static inline uint32_t state_magic(void)
+{
+ if (sizeof(bool) == 1) return 'SAME';
+ return 'S4ME';
+}
+
+void GB_attributed_logv(GB_gameboy_t *gb, GB_log_attributes attributes, const char *fmt, va_list args)
+{
+ char *string = NULL;
+ vasprintf(&string, fmt, args);
+ if (string) {
+ if (gb->log_callback) {
+ gb->log_callback(gb, string, attributes);
+ }
+ else {
+ /* Todo: Add ANSI escape sequences for attributed text */
+ printf("%s", string);
+ }
+ }
+ free(string);
+}
+
+void GB_attributed_log(GB_gameboy_t *gb, GB_log_attributes attributes, const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ GB_attributed_logv(gb, attributes, fmt, args);
+ va_end(args);
+}
+
+void GB_log(GB_gameboy_t *gb, const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ GB_attributed_logv(gb, 0, fmt, args);
+ va_end(args);
+}
+
+#ifndef GB_DISABLE_DEBUGGER
+static char *default_input_callback(GB_gameboy_t *gb)
+{
+ char *expression = NULL;
+ size_t size = 0;
+ if (gb->debug_stopped) {
+ printf(">");
+ }
+
+ if (getline(&expression, &size, stdin) == -1) {
+ /* The user doesn't have STDIN or used ^D. We make sure the program keeps running. */
+ GB_set_async_input_callback(gb, NULL); /* Disable async input */
+ return strdup("c");
+ }
+
+ if (!expression) {
+ return strdup("");
+ }
+
+ size_t length = strlen(expression);
+ if (expression[length - 1] == '\n') {
+ expression[length - 1] = 0;
+ }
+
+ if (expression[0] == '\x03') {
+ gb->debug_stopped = true;
+ free(expression);
+ return strdup("");
+ }
+ return expression;
+}
+
+static char *default_async_input_callback(GB_gameboy_t *gb)
+{
+#ifndef _WIN32
+ fd_set set;
+ FD_ZERO(&set);
+ FD_SET(STDIN_FILENO, &set);
+ struct timeval time = {0,};
+ if (select(1, &set, NULL, NULL, &time) == 1) {
+ if (feof(stdin)) {
+ GB_set_async_input_callback(gb, NULL); /* Disable async input */
+ return NULL;
+ }
+ return default_input_callback(gb);
+ }
+#endif
+ return NULL;
+}
+#endif
+
+static void load_default_border(GB_gameboy_t *gb)
+{
+ if (gb->has_sgb_border) return;
+
+ #define LOAD_BORDER() do { \
+ memcpy(gb->borrowed_border.map, tilemap, sizeof(tilemap));\
+ memcpy(gb->borrowed_border.palette, palette, sizeof(palette));\
+ \
+ /* Expand 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->borrowed_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);\
+ }\
+ }\
+ }\
+ } while (false);
+
+ if (gb->model == GB_MODEL_AGB) {
+ #include "graphics/agb_border.inc"
+ LOAD_BORDER();
+ }
+ else if (GB_is_cgb(gb)) {
+ #include "graphics/cgb_border.inc"
+ LOAD_BORDER();
+ }
+ else {
+ #include "graphics/dmg_border.inc"
+ LOAD_BORDER();
+ }
+}
+
+void GB_init(GB_gameboy_t *gb, GB_model_t model)
+{
+ memset(gb, 0, sizeof(*gb));
+ gb->model = model;
+ if (GB_is_cgb(gb)) {
+ gb->ram = malloc(gb->ram_size = 0x1000 * 8);
+ gb->vram = malloc(gb->vram_size = 0x2000 * 2);
+ }
+ else {
+ gb->ram = malloc(gb->ram_size = 0x2000);
+ gb->vram = malloc(gb->vram_size = 0x2000);
+ }
+
+#ifndef GB_DISABLE_DEBUGGER
+ gb->input_callback = default_input_callback;
+ gb->async_input_callback = default_async_input_callback;
+#endif
+ gb->cartridge_type = &GB_cart_defs[0]; // Default cartridge type
+ gb->clock_multiplier = 1.0;
+
+ if (model & GB_MODEL_NO_SFC_BIT) {
+ /* Disable time syncing. Timing should be done by the SFC emulator. */
+ gb->turbo = true;
+ }
+
+ GB_reset(gb);
+ load_default_border(gb);
+}
+
+GB_model_t GB_get_model(GB_gameboy_t *gb)
+{
+ return gb->model;
+}
+
+void GB_free(GB_gameboy_t *gb)
+{
+ gb->magic = 0;
+ if (gb->ram) {
+ free(gb->ram);
+ }
+ if (gb->vram) {
+ free(gb->vram);
+ }
+ if (gb->mbc_ram) {
+ free(gb->mbc_ram);
+ }
+ if (gb->rom) {
+ free(gb->rom);
+ }
+ if (gb->breakpoints) {
+ free(gb->breakpoints);
+ }
+ if (gb->sgb) {
+ free(gb->sgb);
+ }
+ if (gb->nontrivial_jump_state) {
+ free(gb->nontrivial_jump_state);
+ }
+#ifndef GB_DISABLE_DEBUGGER
+ GB_debugger_clear_symbols(gb);
+#endif
+ GB_rewind_free(gb);
+#ifndef GB_DISABLE_CHEATS
+ while (gb->cheats) {
+ GB_remove_cheat(gb, gb->cheats[0]);
+ }
+#endif
+ memset(gb, 0, sizeof(*gb));
+}
+
+int GB_load_boot_rom(GB_gameboy_t *gb, const char *path)
+{
+ FILE *f = fopen(path, "rb");
+ if (!f) {
+ GB_log(gb, "Could not open boot ROM: %s.\n", strerror(errno));
+ return errno;
+ }
+ fread(gb->boot_rom, sizeof(gb->boot_rom), 1, f);
+ fclose(f);
+ return 0;
+}
+
+void GB_load_boot_rom_from_buffer(GB_gameboy_t *gb, const unsigned char *buffer, size_t size)
+{
+ if (size > sizeof(gb->boot_rom)) {
+ size = sizeof(gb->boot_rom);
+ }
+ memset(gb->boot_rom, 0xFF, sizeof(gb->boot_rom));
+ memcpy(gb->boot_rom, buffer, size);
+}
+
+void GB_borrow_sgb_border(GB_gameboy_t *gb)
+{
+ if (GB_is_sgb(gb)) return;
+ if (gb->border_mode != GB_BORDER_ALWAYS) return;
+ if (gb->tried_loading_sgb_border) return;
+ gb->tried_loading_sgb_border = true;
+ if (gb->rom && gb->rom[0x146] != 3) return; // Not an SGB game, nothing to borrow
+ if (!gb->boot_rom_load_callback) return; // Can't borrow a border without this callback
+ GB_gameboy_t sgb;
+ GB_init(&sgb, GB_MODEL_SGB);
+ sgb.cartridge_type = gb->cartridge_type;
+ sgb.rom = gb->rom;
+ sgb.rom_size = gb->rom_size;
+ sgb.turbo = true;
+ sgb.turbo_dont_skip = true;
+ // sgb.disable_rendering = true;
+
+ /* Load the boot ROM using the existing gb object */
+ typeof(gb->boot_rom) boot_rom_backup;
+ memcpy(boot_rom_backup, gb->boot_rom, sizeof(gb->boot_rom));
+ gb->boot_rom_load_callback(gb, GB_BOOT_ROM_SGB);
+ memcpy(sgb.boot_rom, gb->boot_rom, sizeof(gb->boot_rom));
+ memcpy(gb->boot_rom, boot_rom_backup, sizeof(gb->boot_rom));
+ sgb.sgb->intro_animation = -1;
+
+ for (unsigned i = 600; i--;) {
+ GB_run_frame(&sgb);
+ if (sgb.sgb->border_animation) {
+ gb->has_sgb_border = true;
+ memcpy(&gb->borrowed_border, &sgb.sgb->pending_border, sizeof(gb->borrowed_border));
+ gb->borrowed_border.palette[0] = sgb.sgb->effective_palettes[0];
+ break;
+ }
+ }
+
+ sgb.rom = NULL;
+ sgb.rom_size = 0;
+ GB_free(&sgb);
+}
+
+int GB_load_rom(GB_gameboy_t *gb, const char *path)
+{
+ FILE *f = fopen(path, "rb");
+ if (!f) {
+ GB_log(gb, "Could not open ROM: %s.\n", strerror(errno));
+ return errno;
+ }
+ fseek(f, 0, SEEK_END);
+ gb->rom_size = (ftell(f) + 0x3FFF) & ~0x3FFF; /* Round to bank */
+ /* And then round to a power of two */
+ while (gb->rom_size & (gb->rom_size - 1)) {
+ /* I promise this works. */
+ gb->rom_size |= gb->rom_size >> 1;
+ gb->rom_size++;
+ }
+ if (gb->rom_size == 0) {
+ gb->rom_size = 0x8000;
+ }
+ fseek(f, 0, SEEK_SET);
+ if (gb->rom) {
+ free(gb->rom);
+ }
+ gb->rom = malloc(gb->rom_size);
+ memset(gb->rom, 0xFF, gb->rom_size); /* Pad with 0xFFs */
+ fread(gb->rom, 1, gb->rom_size, f);
+ fclose(f);
+ GB_configure_cart(gb);
+ return 0;
+}
+
+int GB_load_isx(GB_gameboy_t *gb, const char *path)
+{
+ FILE *f = fopen(path, "rb");
+ if (!f) {
+ GB_log(gb, "Could not open ISX file: %s.\n", strerror(errno));
+ return errno;
+ }
+ char magic[4];
+#define READ(x) if (fread(&x, sizeof(x), 1, f) != 1) goto error
+ fread(magic, 1, sizeof(magic), f);
+
+#ifdef GB_BIG_ENDIAN
+ bool extended = *(uint32_t *)&magic == 'ISX ';
+#else
+ bool extended = *(uint32_t *)&magic == __builtin_bswap32('ISX ');
+#endif
+
+ fseek(f, extended? 0x20 : 0, SEEK_SET);
+
+
+ uint8_t *old_rom = gb->rom;
+ uint32_t old_size = gb->rom_size;
+ gb->rom = NULL;
+ gb->rom_size = 0;
+
+ while (true) {
+ uint8_t record_type = 0;
+ if (fread(&record_type, sizeof(record_type), 1, f) != 1) break;
+ switch (record_type) {
+ case 0x01: { // Binary
+ uint16_t bank;
+ uint16_t address;
+ uint16_t length;
+ uint8_t byte;
+ READ(byte);
+ bank = byte;
+ if (byte >= 0x80) {
+ READ(byte);
+ bank |= byte << 8;
+ }
+
+ READ(address);
+#ifdef GB_BIG_ENDIAN
+ address = __builtin_bswap16(address);
+#endif
+ address &= 0x3FFF;
+
+ READ(length);
+#ifdef GB_BIG_ENDIAN
+ length = __builtin_bswap16(length);
+#endif
+
+ size_t needed_size = bank * 0x4000 + address + length;
+ if (needed_size > 1024 * 1024 * 32) goto error;
+
+ if (gb->rom_size < needed_size) {
+ gb->rom = realloc(gb->rom, needed_size);
+ memset(gb->rom + gb->rom_size, 0, needed_size - gb->rom_size);
+ gb->rom_size = needed_size;
+ }
+
+ if (fread(gb->rom + (bank * 0x4000 + address), length, 1, f) != 1) goto error;
+
+ break;
+ }
+
+ case 0x11: { // Extended Binary
+ uint32_t address;
+ uint32_t length;
+
+ READ(address);
+#ifdef GB_BIG_ENDIAN
+ address = __builtin_bswap32(address);
+#endif
+
+ READ(length);
+#ifdef GB_BIG_ENDIAN
+ length = __builtin_bswap32(length);
+#endif
+ size_t needed_size = address + length;
+ if (needed_size > 1024 * 1024 * 32) goto error;
+
+ if (gb->rom_size < needed_size) {
+ gb->rom = realloc(gb->rom, needed_size);
+ memset(gb->rom + gb->rom_size, 0, needed_size - gb->rom_size);
+ gb->rom_size = needed_size;
+ }
+
+ if (fread(gb->rom + address, length, 1, f) != 1) goto error;
+
+ break;
+ }
+
+ case 0x04: { // Symbol
+ uint16_t count;
+ uint8_t length;
+ char name[257];
+ uint8_t flag;
+ uint16_t bank;
+ uint16_t address;
+ uint8_t byte;
+ READ(count);
+#ifdef GB_BIG_ENDIAN
+ count = __builtin_bswap16(count);
+#endif
+ while (count--) {
+ READ(length);
+ if (fread(name, length, 1, f) != 1) goto error;
+ name[length] = 0;
+ READ(flag); // unused
+
+ READ(byte);
+ bank = byte;
+ if (byte >= 0x80) {
+ READ(byte);
+ bank |= byte << 8;
+ }
+
+ READ(address);
+#ifdef GB_BIG_ENDIAN
+ address = __builtin_bswap16(address);
+#endif
+ GB_debugger_add_symbol(gb, bank, address, name);
+ }
+ break;
+ }
+
+ case 0x14: { // Extended Binary
+ uint16_t count;
+ uint8_t length;
+ char name[257];
+ uint8_t flag;
+ uint32_t address;
+ READ(count);
+#ifdef GB_BIG_ENDIAN
+ count = __builtin_bswap16(count);
+#endif
+ while (count--) {
+ READ(length);
+ if (fread(name, length + 1, 1, f) != 1) goto error;
+ name[length] = 0;
+ READ(flag); // unused
+
+ READ(address);
+#ifdef GB_BIG_ENDIAN
+ address = __builtin_bswap32(address);
+#endif
+ // TODO: How to convert 32-bit addresses to Bank:Address? Needs to tell RAM and ROM apart
+ }
+ break;
+ }
+
+ default:
+ goto done;
+ }
+ }
+done:;
+#undef READ
+ if (gb->rom_size == 0) goto error;
+
+ size_t needed_size = (gb->rom_size + 0x3FFF) & ~0x3FFF; /* Round to bank */
+
+ /* And then round to a power of two */
+ while (needed_size & (needed_size - 1)) {
+ /* I promise this works. */
+ needed_size |= needed_size >> 1;
+ needed_size++;
+ }
+
+ if (needed_size < 0x8000) {
+ needed_size = 0x8000;
+ }
+
+ if (gb->rom_size < needed_size) {
+ gb->rom = realloc(gb->rom, needed_size);
+ memset(gb->rom + gb->rom_size, 0, needed_size - gb->rom_size);
+ gb->rom_size = needed_size;
+ }
+
+ GB_configure_cart(gb);
+
+ // Fix a common wrong MBC error
+ if (gb->rom[0x147] == 3) { // MBC1 + RAM + Battery
+ bool needs_fix = false;
+ if (gb->rom_size >= 0x21 * 0x4000) {
+ for (unsigned i = 0x20 * 0x4000; i < 0x21 * 0x4000; i++) {
+ if (gb->rom[i]) {
+ needs_fix = true;
+ break;
+ }
+ }
+ }
+ if (!needs_fix && gb->rom_size >= 0x41 * 0x4000) {
+ for (unsigned i = 0x40 * 0x4000; i < 0x41 * 0x4000; i++) {
+ if (gb->rom[i]) {
+ needs_fix = true;
+ break;
+ }
+ }
+ }
+ if (!needs_fix && gb->rom_size >= 0x61 * 0x4000) {
+ for (unsigned i = 0x60 * 0x4000; i < 0x61 * 0x4000; i++) {
+ if (gb->rom[i]) {
+ needs_fix = true;
+ break;
+ }
+ }
+ }
+ if (needs_fix) {
+ gb->rom[0x147] = 0x10; // MBC3 + RTC + RAM + Battery
+ GB_configure_cart(gb);
+ gb->rom[0x147] = 0x3;
+ GB_log(gb, "ROM claims to use MBC1 but appears to require MBC3 or 5, assuming MBC3.\n");
+ }
+ }
+
+ if (old_rom) {
+ free(old_rom);
+ }
+
+ return 0;
+error:
+ GB_log(gb, "Invalid or unsupported ISX file.\n");
+ if (gb->rom) {
+ free(gb->rom);
+ gb->rom = old_rom;
+ gb->rom_size = old_size;
+ }
+ fclose(f);
+ return -1;
+}
+
+void GB_load_rom_from_buffer(GB_gameboy_t *gb, const uint8_t *buffer, size_t size)
+{
+ gb->rom_size = (size + 0x3fff) & ~0x3fff;
+ while (gb->rom_size & (gb->rom_size - 1)) {
+ gb->rom_size |= gb->rom_size >> 1;
+ gb->rom_size++;
+ }
+ if (gb->rom_size == 0) {
+ gb->rom_size = 0x8000;
+ }
+ if (gb->rom) {
+ free(gb->rom);
+ }
+ gb->rom = malloc(gb->rom_size);
+ memset(gb->rom, 0xff, gb->rom_size);
+ memcpy(gb->rom, buffer, size);
+ GB_configure_cart(gb);
+}
+
+typedef struct {
+ uint8_t seconds;
+ uint8_t padding1[3];
+ uint8_t minutes;
+ uint8_t padding2[3];
+ uint8_t hours;
+ uint8_t padding3[3];
+ uint8_t days;
+ uint8_t padding4[3];
+ uint8_t high;
+ uint8_t padding5[3];
+} GB_vba_rtc_time_t;
+
+typedef struct __attribute__((packed)) {
+ uint64_t last_rtc_second;
+ uint16_t minutes;
+ uint16_t days;
+ uint16_t alarm_minutes, alarm_days;
+ uint8_t alarm_enabled;
+} GB_huc3_rtc_time_t;
+
+typedef union {
+ struct __attribute__((packed)) {
+ GB_rtc_time_t rtc_real;
+ time_t last_rtc_second; /* Platform specific endianess and size */
+ } sameboy_legacy;
+ struct {
+ /* Used by VBA versions with 32-bit timestamp*/
+ GB_vba_rtc_time_t rtc_real, rtc_latched;
+ uint32_t last_rtc_second; /* Always little endian */
+ } vba32;
+ struct {
+ /* Used by BGB and VBA versions with 64-bit timestamp*/
+ GB_vba_rtc_time_t rtc_real, rtc_latched;
+ uint64_t last_rtc_second; /* Always little endian */
+ } vba64;
+} GB_rtc_save_t;
+
+int GB_save_battery_size(GB_gameboy_t *gb)
+{
+ if (!gb->cartridge_type->has_battery) return 0; // Nothing to save.
+ if (gb->mbc_ram_size == 0 && !gb->cartridge_type->has_rtc) return 0; /* Claims to have battery, but has no RAM or RTC */
+
+ if (gb->cartridge_type->mbc_type == GB_HUC3) {
+ return gb->mbc_ram_size + sizeof(GB_huc3_rtc_time_t);
+ }
+ GB_rtc_save_t rtc_save_size;
+ return gb->mbc_ram_size + (gb->cartridge_type->has_rtc ? sizeof(rtc_save_size.vba64) : 0);
+}
+
+int GB_save_battery_to_buffer(GB_gameboy_t *gb, uint8_t *buffer, size_t size)
+{
+ if (!gb->cartridge_type->has_battery) return 0; // Nothing to save.
+ if (gb->mbc_ram_size == 0 && !gb->cartridge_type->has_rtc) return 0; /* Claims to have battery, but has no RAM or RTC */
+
+ if (size < GB_save_battery_size(gb)) return EIO;
+
+ memcpy(buffer, gb->mbc_ram, gb->mbc_ram_size);
+
+ if (gb->cartridge_type->mbc_type == GB_HUC3) {
+ buffer += gb->mbc_ram_size;
+
+#ifdef GB_BIG_ENDIAN
+ GB_huc3_rtc_time_t rtc_save = {
+ __builtin_bswap64(gb->last_rtc_second),
+ __builtin_bswap16(gb->huc3_minutes),
+ __builtin_bswap16(gb->huc3_days),
+ __builtin_bswap16(gb->huc3_alarm_minutes),
+ __builtin_bswap16(gb->huc3_alarm_days),
+ gb->huc3_alarm_enabled,
+ };
+#else
+ GB_huc3_rtc_time_t rtc_save = {
+ gb->last_rtc_second,
+ gb->huc3_minutes,
+ gb->huc3_days,
+ gb->huc3_alarm_minutes,
+ gb->huc3_alarm_days,
+ gb->huc3_alarm_enabled,
+ };
+#endif
+ memcpy(buffer, &rtc_save, sizeof(rtc_save));
+ }
+ else if (gb->cartridge_type->has_rtc) {
+ GB_rtc_save_t rtc_save = {{{{0,}},},};
+ rtc_save.vba64.rtc_real.seconds = gb->rtc_real.seconds;
+ rtc_save.vba64.rtc_real.minutes = gb->rtc_real.minutes;
+ rtc_save.vba64.rtc_real.hours = gb->rtc_real.hours;
+ rtc_save.vba64.rtc_real.days = gb->rtc_real.days;
+ rtc_save.vba64.rtc_real.high = gb->rtc_real.high;
+ rtc_save.vba64.rtc_latched.seconds = gb->rtc_latched.seconds;
+ rtc_save.vba64.rtc_latched.minutes = gb->rtc_latched.minutes;
+ rtc_save.vba64.rtc_latched.hours = gb->rtc_latched.hours;
+ rtc_save.vba64.rtc_latched.days = gb->rtc_latched.days;
+ rtc_save.vba64.rtc_latched.high = gb->rtc_latched.high;
+#ifdef GB_BIG_ENDIAN
+ rtc_save.vba64.last_rtc_second = __builtin_bswap64(gb->last_rtc_second);
+#else
+ rtc_save.vba64.last_rtc_second = gb->last_rtc_second;
+#endif
+ memcpy(buffer + gb->mbc_ram_size, &rtc_save.vba64, sizeof(rtc_save.vba64));
+ }
+
+ errno = 0;
+ return errno;
+}
+
+int GB_save_battery(GB_gameboy_t *gb, const char *path)
+{
+ if (!gb->cartridge_type->has_battery) return 0; // Nothing to save.
+ if (gb->mbc_ram_size == 0 && !gb->cartridge_type->has_rtc) return 0; /* Claims to have battery, but has no RAM or RTC */
+ FILE *f = fopen(path, "wb");
+ if (!f) {
+ GB_log(gb, "Could not open battery save: %s.\n", strerror(errno));
+ return errno;
+ }
+
+ if (fwrite(gb->mbc_ram, 1, gb->mbc_ram_size, f) != gb->mbc_ram_size) {
+ fclose(f);
+ return EIO;
+ }
+ if (gb->cartridge_type->mbc_type == GB_HUC3) {
+#ifdef GB_BIG_ENDIAN
+ GB_huc3_rtc_time_t rtc_save = {
+ __builtin_bswap64(gb->last_rtc_second),
+ __builtin_bswap16(gb->huc3_minutes),
+ __builtin_bswap16(gb->huc3_days),
+ __builtin_bswap16(gb->huc3_alarm_minutes),
+ __builtin_bswap16(gb->huc3_alarm_days),
+ gb->huc3_alarm_enabled,
+ };
+#else
+ GB_huc3_rtc_time_t rtc_save = {
+ gb->last_rtc_second,
+ gb->huc3_minutes,
+ gb->huc3_days,
+ gb->huc3_alarm_minutes,
+ gb->huc3_alarm_days,
+ gb->huc3_alarm_enabled,
+ };
+#endif
+
+ if (fwrite(&rtc_save, sizeof(rtc_save), 1, f) != 1) {
+ fclose(f);
+ return EIO;
+ }
+ }
+ else if (gb->cartridge_type->has_rtc) {
+ GB_rtc_save_t rtc_save = {{{{0,}},},};
+ rtc_save.vba64.rtc_real.seconds = gb->rtc_real.seconds;
+ rtc_save.vba64.rtc_real.minutes = gb->rtc_real.minutes;
+ rtc_save.vba64.rtc_real.hours = gb->rtc_real.hours;
+ rtc_save.vba64.rtc_real.days = gb->rtc_real.days;
+ rtc_save.vba64.rtc_real.high = gb->rtc_real.high;
+ rtc_save.vba64.rtc_latched.seconds = gb->rtc_latched.seconds;
+ rtc_save.vba64.rtc_latched.minutes = gb->rtc_latched.minutes;
+ rtc_save.vba64.rtc_latched.hours = gb->rtc_latched.hours;
+ rtc_save.vba64.rtc_latched.days = gb->rtc_latched.days;
+ rtc_save.vba64.rtc_latched.high = gb->rtc_latched.high;
+#ifdef GB_BIG_ENDIAN
+ rtc_save.vba64.last_rtc_second = __builtin_bswap64(gb->last_rtc_second);
+#else
+ rtc_save.vba64.last_rtc_second = gb->last_rtc_second;
+#endif
+ if (fwrite(&rtc_save.vba64, 1, sizeof(rtc_save.vba64), f) != sizeof(rtc_save.vba64)) {
+ fclose(f);
+ return EIO;
+ }
+
+ }
+
+ errno = 0;
+ fclose(f);
+ return errno;
+}
+
+void GB_load_battery_from_buffer(GB_gameboy_t *gb, const uint8_t *buffer, size_t size)
+{
+ memcpy(gb->mbc_ram, buffer, MIN(gb->mbc_ram_size, size));
+ if (size <= gb->mbc_ram_size) {
+ goto reset_rtc;
+ }
+
+ if (gb->cartridge_type->mbc_type == GB_HUC3) {
+ GB_huc3_rtc_time_t rtc_save;
+ if (size - gb->mbc_ram_size < sizeof(rtc_save)) {
+ goto reset_rtc;
+ }
+ memcpy(&rtc_save, buffer + gb->mbc_ram_size, sizeof(rtc_save));
+#ifdef GB_BIG_ENDIAN
+ gb->last_rtc_second = __builtin_bswap64(rtc_save.last_rtc_second);
+ gb->huc3_minutes = __builtin_bswap16(rtc_save.minutes);
+ gb->huc3_days = __builtin_bswap16(rtc_save.days);
+ gb->huc3_alarm_minutes = __builtin_bswap16(rtc_save.alarm_minutes);
+ gb->huc3_alarm_days = __builtin_bswap16(rtc_save.alarm_days);
+ gb->huc3_alarm_enabled = rtc_save.alarm_enabled;
+#else
+ gb->last_rtc_second = rtc_save.last_rtc_second;
+ gb->huc3_minutes = rtc_save.minutes;
+ gb->huc3_days = rtc_save.days;
+ gb->huc3_alarm_minutes = rtc_save.alarm_minutes;
+ gb->huc3_alarm_days = rtc_save.alarm_days;
+ gb->huc3_alarm_enabled = rtc_save.alarm_enabled;
+#endif
+ if (gb->last_rtc_second > time(NULL)) {
+ /* We must reset RTC here, or it will not advance. */
+ goto reset_rtc;
+ }
+ return;
+ }
+
+ GB_rtc_save_t rtc_save;
+ memcpy(&rtc_save, buffer + gb->mbc_ram_size, MIN(sizeof(rtc_save), size));
+ switch (size - gb->mbc_ram_size) {
+ case sizeof(rtc_save.sameboy_legacy):
+ memcpy(&gb->rtc_real, &rtc_save.sameboy_legacy.rtc_real, sizeof(gb->rtc_real));
+ memcpy(&gb->rtc_latched, &rtc_save.sameboy_legacy.rtc_real, sizeof(gb->rtc_real));
+ gb->last_rtc_second = rtc_save.sameboy_legacy.last_rtc_second;
+ break;
+
+ case sizeof(rtc_save.vba32):
+ gb->rtc_real.seconds = rtc_save.vba32.rtc_real.seconds;
+ gb->rtc_real.minutes = rtc_save.vba32.rtc_real.minutes;
+ gb->rtc_real.hours = rtc_save.vba32.rtc_real.hours;
+ gb->rtc_real.days = rtc_save.vba32.rtc_real.days;
+ gb->rtc_real.high = rtc_save.vba32.rtc_real.high;
+ gb->rtc_latched.seconds = rtc_save.vba32.rtc_latched.seconds;
+ gb->rtc_latched.minutes = rtc_save.vba32.rtc_latched.minutes;
+ gb->rtc_latched.hours = rtc_save.vba32.rtc_latched.hours;
+ gb->rtc_latched.days = rtc_save.vba32.rtc_latched.days;
+ gb->rtc_latched.high = rtc_save.vba32.rtc_latched.high;
+#ifdef GB_BIG_ENDIAN
+ gb->last_rtc_second = __builtin_bswap32(rtc_save.vba32.last_rtc_second);
+#else
+ gb->last_rtc_second = rtc_save.vba32.last_rtc_second;
+#endif
+ break;
+
+ case sizeof(rtc_save.vba64):
+ gb->rtc_real.seconds = rtc_save.vba64.rtc_real.seconds;
+ gb->rtc_real.minutes = rtc_save.vba64.rtc_real.minutes;
+ gb->rtc_real.hours = rtc_save.vba64.rtc_real.hours;
+ gb->rtc_real.days = rtc_save.vba64.rtc_real.days;
+ gb->rtc_real.high = rtc_save.vba64.rtc_real.high;
+ gb->rtc_latched.seconds = rtc_save.vba64.rtc_latched.seconds;
+ gb->rtc_latched.minutes = rtc_save.vba64.rtc_latched.minutes;
+ gb->rtc_latched.hours = rtc_save.vba64.rtc_latched.hours;
+ gb->rtc_latched.days = rtc_save.vba64.rtc_latched.days;
+ gb->rtc_latched.high = rtc_save.vba64.rtc_latched.high;
+#ifdef GB_BIG_ENDIAN
+ gb->last_rtc_second = __builtin_bswap64(rtc_save.vba64.last_rtc_second);
+#else
+ gb->last_rtc_second = rtc_save.vba64.last_rtc_second;
+#endif
+ break;
+
+ default:
+ goto reset_rtc;
+ }
+ if (gb->last_rtc_second > time(NULL)) {
+ /* We must reset RTC here, or it will not advance. */
+ goto reset_rtc;
+ }
+
+ if (gb->last_rtc_second < 852076800) { /* 1/1/97. There weren't any RTC games that time,
+ so if the value we read is lower it means it wasn't
+ really RTC data. */
+ goto reset_rtc;
+ }
+ goto exit;
+reset_rtc:
+ gb->last_rtc_second = time(NULL);
+ gb->rtc_real.high |= 0x80; /* This gives the game a hint that the clock should be reset. */
+ gb->huc3_days = 0xFFFF;
+ gb->huc3_minutes = 0xFFF;
+ gb->huc3_alarm_enabled = false;
+exit:
+ return;
+}
+
+/* Loading will silently stop if the format is incomplete */
+void GB_load_battery(GB_gameboy_t *gb, const char *path)
+{
+ FILE *f = fopen(path, "rb");
+ if (!f) {
+ return;
+ }
+
+ if (fread(gb->mbc_ram, 1, gb->mbc_ram_size, f) != gb->mbc_ram_size) {
+ goto reset_rtc;
+ }
+
+ if (gb->cartridge_type->mbc_type == GB_HUC3) {
+ GB_huc3_rtc_time_t rtc_save;
+ if (fread(&rtc_save, sizeof(rtc_save), 1, f) != 1) {
+ goto reset_rtc;
+ }
+#ifdef GB_BIG_ENDIAN
+ gb->last_rtc_second = __builtin_bswap64(rtc_save.last_rtc_second);
+ gb->huc3_minutes = __builtin_bswap16(rtc_save.minutes);
+ gb->huc3_days = __builtin_bswap16(rtc_save.days);
+ gb->huc3_alarm_minutes = __builtin_bswap16(rtc_save.alarm_minutes);
+ gb->huc3_alarm_days = __builtin_bswap16(rtc_save.alarm_days);
+ gb->huc3_alarm_enabled = rtc_save.alarm_enabled;
+#else
+ gb->last_rtc_second = rtc_save.last_rtc_second;
+ gb->huc3_minutes = rtc_save.minutes;
+ gb->huc3_days = rtc_save.days;
+ gb->huc3_alarm_minutes = rtc_save.alarm_minutes;
+ gb->huc3_alarm_days = rtc_save.alarm_days;
+ gb->huc3_alarm_enabled = rtc_save.alarm_enabled;
+#endif
+ if (gb->last_rtc_second > time(NULL)) {
+ /* We must reset RTC here, or it will not advance. */
+ goto reset_rtc;
+ }
+ return;
+ }
+
+ GB_rtc_save_t rtc_save;
+ switch (fread(&rtc_save, 1, sizeof(rtc_save), f)) {
+ case sizeof(rtc_save.sameboy_legacy):
+ memcpy(&gb->rtc_real, &rtc_save.sameboy_legacy.rtc_real, sizeof(gb->rtc_real));
+ memcpy(&gb->rtc_latched, &rtc_save.sameboy_legacy.rtc_real, sizeof(gb->rtc_real));
+ gb->last_rtc_second = rtc_save.sameboy_legacy.last_rtc_second;
+ break;
+
+ case sizeof(rtc_save.vba32):
+ gb->rtc_real.seconds = rtc_save.vba32.rtc_real.seconds;
+ gb->rtc_real.minutes = rtc_save.vba32.rtc_real.minutes;
+ gb->rtc_real.hours = rtc_save.vba32.rtc_real.hours;
+ gb->rtc_real.days = rtc_save.vba32.rtc_real.days;
+ gb->rtc_real.high = rtc_save.vba32.rtc_real.high;
+ gb->rtc_latched.seconds = rtc_save.vba32.rtc_latched.seconds;
+ gb->rtc_latched.minutes = rtc_save.vba32.rtc_latched.minutes;
+ gb->rtc_latched.hours = rtc_save.vba32.rtc_latched.hours;
+ gb->rtc_latched.days = rtc_save.vba32.rtc_latched.days;
+ gb->rtc_latched.high = rtc_save.vba32.rtc_latched.high;
+#ifdef GB_BIG_ENDIAN
+ gb->last_rtc_second = __builtin_bswap32(rtc_save.vba32.last_rtc_second);
+#else
+ gb->last_rtc_second = rtc_save.vba32.last_rtc_second;
+#endif
+ break;
+
+ case sizeof(rtc_save.vba64):
+ gb->rtc_real.seconds = rtc_save.vba64.rtc_real.seconds;
+ gb->rtc_real.minutes = rtc_save.vba64.rtc_real.minutes;
+ gb->rtc_real.hours = rtc_save.vba64.rtc_real.hours;
+ gb->rtc_real.days = rtc_save.vba64.rtc_real.days;
+ gb->rtc_real.high = rtc_save.vba64.rtc_real.high;
+ gb->rtc_latched.seconds = rtc_save.vba64.rtc_latched.seconds;
+ gb->rtc_latched.minutes = rtc_save.vba64.rtc_latched.minutes;
+ gb->rtc_latched.hours = rtc_save.vba64.rtc_latched.hours;
+ gb->rtc_latched.days = rtc_save.vba64.rtc_latched.days;
+ gb->rtc_latched.high = rtc_save.vba64.rtc_latched.high;
+#ifdef GB_BIG_ENDIAN
+ gb->last_rtc_second = __builtin_bswap64(rtc_save.vba64.last_rtc_second);
+#else
+ gb->last_rtc_second = rtc_save.vba64.last_rtc_second;
+#endif
+ break;
+
+ default:
+ goto reset_rtc;
+ }
+ if (gb->last_rtc_second > time(NULL)) {
+ /* We must reset RTC here, or it will not advance. */
+ goto reset_rtc;
+ }
+
+ if (gb->last_rtc_second < 852076800) { /* 1/1/97. There weren't any RTC games that time,
+ so if the value we read is lower it means it wasn't
+ really RTC data. */
+ goto reset_rtc;
+ }
+ goto exit;
+reset_rtc:
+ gb->last_rtc_second = time(NULL);
+ gb->rtc_real.high |= 0x80; /* This gives the game a hint that the clock should be reset. */
+ gb->huc3_days = 0xFFFF;
+ gb->huc3_minutes = 0xFFF;
+ gb->huc3_alarm_enabled = false;
+exit:
+ fclose(f);
+ return;
+}
+
+uint8_t GB_run(GB_gameboy_t *gb)
+{
+ gb->vblank_just_occured = false;
+
+ if (gb->sgb && gb->sgb->intro_animation < 140) {
+ /* On the SGB, the GB is halted after finishing the boot ROM.
+ Then, after the boot animation is almost done, it's reset.
+ Since the SGB HLE does not perform any header validity checks,
+ we just halt the CPU (with hacky code) until the correct time.
+ This ensures the Nintendo logo doesn't flash on screen, and
+ the game does "run in background" while the animation is playing. */
+ GB_display_run(gb, 228);
+ gb->cycles_since_last_sync += 228;
+ return 228;
+ }
+
+ GB_debugger_run(gb);
+ gb->cycles_since_run = 0;
+ GB_cpu_run(gb);
+ if (gb->vblank_just_occured) {
+ GB_rtc_run(gb);
+ GB_debugger_handle_async_commands(gb);
+ GB_rewind_push(gb);
+ }
+ return gb->cycles_since_run;
+}
+
+uint64_t GB_run_frame(GB_gameboy_t *gb)
+{
+ /* Configure turbo temporarily, the user wants to handle FPS capping manually. */
+ bool old_turbo = gb->turbo;
+ bool old_dont_skip = gb->turbo_dont_skip;
+ gb->turbo = true;
+ gb->turbo_dont_skip = true;
+
+ gb->cycles_since_last_sync = 0;
+ while (true) {
+ GB_run(gb);
+ if (gb->vblank_just_occured) {
+ break;
+ }
+ }
+ gb->turbo = old_turbo;
+ gb->turbo_dont_skip = old_dont_skip;
+ return gb->cycles_since_last_sync * 1000000000LL / 2 / GB_get_clock_rate(gb); /* / 2 because we use 8MHz units */
+}
+
+void GB_set_pixels_output(GB_gameboy_t *gb, uint32_t *output)
+{
+ gb->screen = output;
+}
+
+void GB_set_vblank_callback(GB_gameboy_t *gb, GB_vblank_callback_t callback)
+{
+ gb->vblank_callback = callback;
+}
+
+void GB_set_log_callback(GB_gameboy_t *gb, GB_log_callback_t callback)
+{
+ gb->log_callback = callback;
+}
+
+void GB_set_input_callback(GB_gameboy_t *gb, GB_input_callback_t callback)
+{
+#ifndef GB_DISABLE_DEBUGGER
+ if (gb->input_callback == default_input_callback) {
+ gb->async_input_callback = NULL;
+ }
+ gb->input_callback = callback;
+#endif
+}
+
+void GB_set_async_input_callback(GB_gameboy_t *gb, GB_input_callback_t callback)
+{
+#ifndef GB_DISABLE_DEBUGGER
+ gb->async_input_callback = callback;
+#endif
+}
+
+const GB_palette_t GB_PALETTE_GREY = {{{0x00, 0x00, 0x00}, {0x55, 0x55, 0x55}, {0xaa, 0xaa, 0xaa}, {0xff, 0xff, 0xff}, {0xff, 0xff, 0xff}}};
+const GB_palette_t GB_PALETTE_DMG = {{{0x08, 0x18, 0x10}, {0x39, 0x61, 0x39}, {0x84, 0xa5, 0x63}, {0xc6, 0xde, 0x8c}, {0xd2, 0xe6, 0xa6}}};
+const GB_palette_t GB_PALETTE_MGB = {{{0x07, 0x10, 0x0e}, {0x3a, 0x4c, 0x3a}, {0x81, 0x8d, 0x66}, {0xc2, 0xce, 0x93}, {0xcf, 0xda, 0xac}}};
+const GB_palette_t GB_PALETTE_GBL = {{{0x0a, 0x1c, 0x15}, {0x35, 0x78, 0x62}, {0x56, 0xb4, 0x95}, {0x7f, 0xe2, 0xc3}, {0x91, 0xea, 0xd0}}};
+
+static void update_dmg_palette(GB_gameboy_t *gb)
+{
+ const GB_palette_t *palette = gb->dmg_palette ?: &GB_PALETTE_GREY;
+ if (gb->rgb_encode_callback && !GB_is_cgb(gb)) {
+ gb->sprite_palettes_rgb[4] = gb->sprite_palettes_rgb[0] = gb->background_palettes_rgb[0] =
+ gb->rgb_encode_callback(gb, palette->colors[3].r, palette->colors[3].g, palette->colors[3].b);
+ gb->sprite_palettes_rgb[5] = gb->sprite_palettes_rgb[1] = gb->background_palettes_rgb[1] =
+ gb->rgb_encode_callback(gb, palette->colors[2].r, palette->colors[2].g, palette->colors[2].b);
+ gb->sprite_palettes_rgb[6] = gb->sprite_palettes_rgb[2] = gb->background_palettes_rgb[2] =
+ gb->rgb_encode_callback(gb, palette->colors[1].r, palette->colors[1].g, palette->colors[1].b);
+ gb->sprite_palettes_rgb[7] = gb->sprite_palettes_rgb[3] = gb->background_palettes_rgb[3] =
+ gb->rgb_encode_callback(gb, palette->colors[0].r, palette->colors[0].g, palette->colors[0].b);
+
+ // LCD off color
+ gb->background_palettes_rgb[4] =
+ gb->rgb_encode_callback(gb, palette->colors[4].r, palette->colors[4].g, palette->colors[4].b);
+ }
+}
+
+void GB_set_palette(GB_gameboy_t *gb, const GB_palette_t *palette)
+{
+ gb->dmg_palette = palette;
+ update_dmg_palette(gb);
+}
+
+void GB_set_rgb_encode_callback(GB_gameboy_t *gb, GB_rgb_encode_callback_t callback)
+{
+
+ gb->rgb_encode_callback = callback;
+ update_dmg_palette(gb);
+
+ for (unsigned i = 0; i < 32; i++) {
+ GB_palette_changed(gb, true, i * 2);
+ GB_palette_changed(gb, false, i * 2);
+ }
+}
+
+void GB_set_infrared_callback(GB_gameboy_t *gb, GB_infrared_callback_t callback)
+{
+ gb->infrared_callback = callback;
+}
+
+void GB_set_infrared_input(GB_gameboy_t *gb, bool state)
+{
+ gb->infrared_input = state;
+ gb->cycles_since_input_ir_change = 0;
+ gb->ir_queue_length = 0;
+}
+
+void GB_queue_infrared_input(GB_gameboy_t *gb, bool state, uint64_t cycles_after_previous_change)
+{
+ if (gb->ir_queue_length == GB_MAX_IR_QUEUE) {
+ GB_log(gb, "IR Queue is full\n");
+ return;
+ }
+ gb->ir_queue[gb->ir_queue_length++] = (GB_ir_queue_item_t){state, cycles_after_previous_change};
+}
+
+void GB_set_rumble_callback(GB_gameboy_t *gb, GB_rumble_callback_t callback)
+{
+ gb->rumble_callback = callback;
+}
+
+void GB_set_serial_transfer_bit_start_callback(GB_gameboy_t *gb, GB_serial_transfer_bit_start_callback_t callback)
+{
+ gb->serial_transfer_bit_start_callback = callback;
+}
+
+void GB_set_serial_transfer_bit_end_callback(GB_gameboy_t *gb, GB_serial_transfer_bit_end_callback_t callback)
+{
+ gb->serial_transfer_bit_end_callback = callback;
+}
+
+bool GB_serial_get_data_bit(GB_gameboy_t *gb)
+{
+ if (gb->io_registers[GB_IO_SC] & 1) {
+ /* Internal Clock */
+ GB_log(gb, "Serial read request while using internal clock. \n");
+ return 0xFF;
+ }
+ return gb->io_registers[GB_IO_SB] & 0x80;
+}
+void GB_serial_set_data_bit(GB_gameboy_t *gb, bool data)
+{
+ if (gb->io_registers[GB_IO_SC] & 1) {
+ /* Internal Clock */
+ GB_log(gb, "Serial write request while using internal clock. \n");
+ return;
+ }
+ gb->io_registers[GB_IO_SB] <<= 1;
+ gb->io_registers[GB_IO_SB] |= data;
+ gb->serial_count++;
+ if (gb->serial_count == 8) {
+ gb->io_registers[GB_IO_IF] |= 8;
+ gb->serial_count = 0;
+ }
+}
+
+void GB_disconnect_serial(GB_gameboy_t *gb)
+{
+ gb->serial_transfer_bit_start_callback = NULL;
+ gb->serial_transfer_bit_end_callback = NULL;
+
+ /* Reset any internally-emulated device. */
+ memset(&gb->printer, 0, sizeof(gb->printer));
+ memset(&gb->workboy, 0, sizeof(gb->workboy));
+}
+
+bool GB_is_inited(GB_gameboy_t *gb)
+{
+ return gb->magic == state_magic();
+}
+
+bool GB_is_cgb(GB_gameboy_t *gb)
+{
+ return (gb->model & GB_MODEL_FAMILY_MASK) == GB_MODEL_CGB_FAMILY;
+}
+
+bool GB_is_sgb(GB_gameboy_t *gb)
+{
+ return (gb->model & ~GB_MODEL_PAL_BIT & ~GB_MODEL_NO_SFC_BIT) == GB_MODEL_SGB || (gb->model & ~GB_MODEL_NO_SFC_BIT) == GB_MODEL_SGB2;
+}
+
+bool GB_is_hle_sgb(GB_gameboy_t *gb)
+{
+ return (gb->model & ~GB_MODEL_PAL_BIT) == GB_MODEL_SGB || gb->model == GB_MODEL_SGB2;
+}
+
+void GB_set_turbo_mode(GB_gameboy_t *gb, bool on, bool no_frame_skip)
+{
+ gb->turbo = on;
+ gb->turbo_dont_skip = no_frame_skip;
+}
+
+void GB_set_rendering_disabled(GB_gameboy_t *gb, bool disabled)
+{
+ gb->disable_rendering = disabled;
+}
+
+void *GB_get_user_data(GB_gameboy_t *gb)
+{
+ return gb->user_data;
+}
+
+void GB_set_user_data(GB_gameboy_t *gb, void *data)
+{
+ gb->user_data = data;
+}
+
+static void reset_ram(GB_gameboy_t *gb)
+{
+ switch (gb->model) {
+ case GB_MODEL_CGB_E:
+ case GB_MODEL_AGB: /* Unverified */
+ for (unsigned i = 0; i < gb->ram_size; i++) {
+ gb->ram[i] = GB_random();
+ }
+ break;
+
+ case GB_MODEL_DMG_B:
+ case GB_MODEL_SGB_NTSC: /* Unverified*/
+ case GB_MODEL_SGB_PAL: /* Unverified */
+ case GB_MODEL_SGB_NTSC_NO_SFC: /* Unverified */
+ case GB_MODEL_SGB_PAL_NO_SFC: /* Unverified */
+ for (unsigned i = 0; i < gb->ram_size; i++) {
+ gb->ram[i] = GB_random();
+ if (i & 0x100) {
+ gb->ram[i] &= GB_random();
+ }
+ else {
+ gb->ram[i] |= GB_random();
+ }
+ }
+ break;
+
+ case GB_MODEL_SGB2:
+ case GB_MODEL_SGB2_NO_SFC:
+ for (unsigned i = 0; i < gb->ram_size; i++) {
+ gb->ram[i] = 0x55;
+ gb->ram[i] ^= GB_random() & GB_random() & GB_random();
+ }
+ break;
+
+ case GB_MODEL_CGB_C:
+ for (unsigned i = 0; i < gb->ram_size; i++) {
+ if ((i & 0x808) == 0x800 || (i & 0x808) == 0x008) {
+ gb->ram[i] = 0;
+ }
+ else {
+ gb->ram[i] = GB_random() | GB_random() | GB_random() | GB_random();
+ }
+ }
+ break;
+ }
+
+ /* HRAM */
+ switch (gb->model) {
+ case GB_MODEL_CGB_C:
+ // case GB_MODEL_CGB_D:
+ case GB_MODEL_CGB_E:
+ case GB_MODEL_AGB:
+ for (unsigned i = 0; i < sizeof(gb->hram); i++) {
+ gb->hram[i] = GB_random();
+ }
+ break;
+
+ case GB_MODEL_DMG_B:
+ case GB_MODEL_SGB_NTSC: /* Unverified*/
+ case GB_MODEL_SGB_PAL: /* Unverified */
+ case GB_MODEL_SGB_NTSC_NO_SFC: /* Unverified */
+ case GB_MODEL_SGB_PAL_NO_SFC: /* Unverified */
+ case GB_MODEL_SGB2:
+ case GB_MODEL_SGB2_NO_SFC:
+ for (unsigned i = 0; i < sizeof(gb->hram); i++) {
+ if (i & 1) {
+ gb->hram[i] = GB_random() | GB_random() | GB_random();
+ }
+ else {
+ gb->hram[i] = GB_random() & GB_random() & GB_random();
+ }
+ }
+ break;
+ }
+
+ /* OAM */
+ switch (gb->model) {
+ case GB_MODEL_CGB_C:
+ case GB_MODEL_CGB_E:
+ case GB_MODEL_AGB:
+ /* Zero'd out by boot ROM anyway*/
+ break;
+
+ case GB_MODEL_DMG_B:
+ case GB_MODEL_SGB_NTSC: /* Unverified */
+ case GB_MODEL_SGB_PAL: /* Unverified */
+ case GB_MODEL_SGB_NTSC_NO_SFC: /* Unverified */
+ case GB_MODEL_SGB_PAL_NO_SFC: /* Unverified */
+ case GB_MODEL_SGB2:
+ case GB_MODEL_SGB2_NO_SFC:
+ for (unsigned i = 0; i < 8; i++) {
+ if (i & 2) {
+ gb->oam[i] = GB_random() & GB_random() & GB_random();
+ }
+ else {
+ gb->oam[i] = GB_random() | GB_random() | GB_random();
+ }
+ }
+ for (unsigned i = 8; i < sizeof(gb->oam); i++) {
+ gb->oam[i] = gb->oam[i - 8];
+ }
+ break;
+ }
+
+ /* Wave RAM */
+ switch (gb->model) {
+ case GB_MODEL_CGB_C:
+ case GB_MODEL_CGB_E:
+ case GB_MODEL_AGB:
+ /* Initialized by CGB-A and newer, 0s in CGB-0*/
+ break;
+
+ case GB_MODEL_DMG_B:
+ case GB_MODEL_SGB_NTSC: /* Unverified*/
+ case GB_MODEL_SGB_PAL: /* Unverified */
+ case GB_MODEL_SGB_NTSC_NO_SFC: /* Unverified */
+ case GB_MODEL_SGB_PAL_NO_SFC: /* Unverified */
+ case GB_MODEL_SGB2:
+ case GB_MODEL_SGB2_NO_SFC: {
+ uint8_t temp;
+ for (unsigned i = 0; i < GB_IO_WAV_END - GB_IO_WAV_START; i++) {
+ if (i & 1) {
+ temp = GB_random() & GB_random() & GB_random();
+ }
+ else {
+ temp = GB_random() | GB_random() | GB_random();
+ }
+ gb->apu.wave_channel.wave_form[i * 2] = temp >> 4;
+ gb->apu.wave_channel.wave_form[i * 2 + 1] = temp & 0xF;
+ gb->io_registers[GB_IO_WAV_START + i] = temp;
+
+ }
+ break;
+ }
+ }
+
+ for (unsigned i = 0; i < sizeof(gb->extra_oam); i++) {
+ gb->extra_oam[i] = GB_random();
+ }
+
+ if (GB_is_cgb(gb)) {
+ for (unsigned i = 0; i < 64; i++) {
+ gb->background_palettes_data[i] = GB_random(); /* Doesn't really matter as the boot ROM overrides it anyway*/
+ gb->sprite_palettes_data[i] = GB_random();
+ }
+ for (unsigned i = 0; i < 32; i++) {
+ GB_palette_changed(gb, true, i * 2);
+ GB_palette_changed(gb, false, i * 2);
+ }
+ }
+}
+
+static void request_boot_rom(GB_gameboy_t *gb)
+{
+ if (gb->boot_rom_load_callback) {
+ GB_boot_rom_t type = 0;
+ switch (gb->model) {
+ case GB_MODEL_DMG_B:
+ type = GB_BOOT_ROM_DMG;
+ break;
+ case GB_MODEL_SGB_NTSC:
+ case GB_MODEL_SGB_PAL:
+ case GB_MODEL_SGB_NTSC_NO_SFC:
+ case GB_MODEL_SGB_PAL_NO_SFC:
+ type = GB_BOOT_ROM_SGB;
+ break;
+ case GB_MODEL_SGB2:
+ case GB_MODEL_SGB2_NO_SFC:
+ type = GB_BOOT_ROM_SGB2;
+ break;
+ case GB_MODEL_CGB_C:
+ case GB_MODEL_CGB_E:
+ type = GB_BOOT_ROM_CGB;
+ break;
+ case GB_MODEL_AGB:
+ type = GB_BOOT_ROM_AGB;
+ break;
+ }
+ gb->boot_rom_load_callback(gb, type);
+ }
+}
+
+void GB_reset(GB_gameboy_t *gb)
+{
+ uint32_t mbc_ram_size = gb->mbc_ram_size;
+ GB_model_t model = gb->model;
+ memset(gb, 0, (size_t)GB_GET_SECTION((GB_gameboy_t *) 0, unsaved));
+ gb->model = model;
+ gb->version = GB_STRUCT_VERSION;
+
+ gb->mbc_rom_bank = 1;
+ gb->last_rtc_second = time(NULL);
+ gb->cgb_ram_bank = 1;
+ gb->io_registers[GB_IO_JOYP] = 0xCF;
+ gb->mbc_ram_size = mbc_ram_size;
+ if (GB_is_cgb(gb)) {
+ gb->ram_size = 0x1000 * 8;
+ gb->vram_size = 0x2000 * 2;
+ memset(gb->vram, 0, gb->vram_size);
+ gb->cgb_mode = true;
+ gb->object_priority = GB_OBJECT_PRIORITY_INDEX;
+ }
+ else {
+ gb->ram_size = 0x2000;
+ gb->vram_size = 0x2000;
+ memset(gb->vram, 0, gb->vram_size);
+ gb->object_priority = GB_OBJECT_PRIORITY_X;
+
+ update_dmg_palette(gb);
+ }
+ reset_ram(gb);
+
+ /* The serial interrupt always occur on the 0xF7th cycle of every 0x100 cycle since boot. */
+ gb->serial_cycles = 0x100-0xF7;
+ gb->io_registers[GB_IO_SC] = 0x7E;
+
+ /* These are not deterministic, but 00 (CGB) and FF (DMG) are the most common initial values by far */
+ gb->io_registers[GB_IO_DMA] = gb->io_registers[GB_IO_OBP0] = gb->io_registers[GB_IO_OBP1] = GB_is_cgb(gb)? 0x00 : 0xFF;
+
+ gb->accessed_oam_row = -1;
+
+
+ if (GB_is_hle_sgb(gb)) {
+ if (!gb->sgb) {
+ gb->sgb = malloc(sizeof(*gb->sgb));
+ }
+ memset(gb->sgb, 0, sizeof(*gb->sgb));
+ memset(gb->sgb_intro_jingle_phases, 0, sizeof(gb->sgb_intro_jingle_phases));
+ gb->sgb_intro_sweep_phase = 0;
+ gb->sgb_intro_sweep_previous_sample = 0;
+ gb->sgb->intro_animation = -10;
+
+ gb->sgb->player_count = 1;
+ GB_sgb_load_default_data(gb);
+
+ }
+ else {
+ if (gb->sgb) {
+ free(gb->sgb);
+ gb->sgb = NULL;
+ }
+ }
+
+ /* Todo: Ugly, fixme, see comment in the timer state machine */
+ gb->div_state = 3;
+
+ GB_apu_update_cycles_per_sample(gb);
+
+ if (gb->nontrivial_jump_state) {
+ free(gb->nontrivial_jump_state);
+ gb->nontrivial_jump_state = NULL;
+ }
+
+ gb->magic = state_magic();
+ request_boot_rom(gb);
+}
+
+void GB_switch_model_and_reset(GB_gameboy_t *gb, GB_model_t model)
+{
+ gb->model = model;
+ if (GB_is_cgb(gb)) {
+ gb->ram = realloc(gb->ram, gb->ram_size = 0x1000 * 8);
+ gb->vram = realloc(gb->vram, gb->vram_size = 0x2000 * 2);
+ }
+ else {
+ gb->ram = realloc(gb->ram, gb->ram_size = 0x2000);
+ gb->vram = realloc(gb->vram, gb->vram_size = 0x2000);
+ }
+ GB_rewind_free(gb);
+ GB_reset(gb);
+ load_default_border(gb);
+}
+
+void *GB_get_direct_access(GB_gameboy_t *gb, GB_direct_access_t access, size_t *size, uint16_t *bank)
+{
+ /* Set size and bank to dummy pointers if not set */
+ size_t dummy_size;
+ uint16_t dummy_bank;
+ if (!size) {
+ size = &dummy_size;
+ }
+
+ if (!bank) {
+ bank = &dummy_bank;
+ }
+
+
+ switch (access) {
+ case GB_DIRECT_ACCESS_ROM:
+ *size = gb->rom_size;
+ *bank = gb->mbc_rom_bank;
+ return gb->rom;
+ case GB_DIRECT_ACCESS_RAM:
+ *size = gb->ram_size;
+ *bank = gb->cgb_ram_bank;
+ return gb->ram;
+ case GB_DIRECT_ACCESS_CART_RAM:
+ *size = gb->mbc_ram_size;
+ *bank = gb->mbc_ram_bank;
+ return gb->mbc_ram;
+ case GB_DIRECT_ACCESS_VRAM:
+ *size = gb->vram_size;
+ *bank = gb->cgb_vram_bank;
+ return gb->vram;
+ case GB_DIRECT_ACCESS_HRAM:
+ *size = sizeof(gb->hram);
+ *bank = 0;
+ return &gb->hram;
+ case GB_DIRECT_ACCESS_IO:
+ *size = sizeof(gb->io_registers);
+ *bank = 0;
+ return &gb->io_registers;
+ case GB_DIRECT_ACCESS_BOOTROM:
+ *size = GB_is_cgb(gb)? sizeof(gb->boot_rom) : 0x100;
+ *bank = 0;
+ return &gb->boot_rom;
+ case GB_DIRECT_ACCESS_OAM:
+ *size = sizeof(gb->oam);
+ *bank = 0;
+ return &gb->oam;
+ case GB_DIRECT_ACCESS_BGP:
+ *size = sizeof(gb->background_palettes_data);
+ *bank = 0;
+ return &gb->background_palettes_data;
+ case GB_DIRECT_ACCESS_OBP:
+ *size = sizeof(gb->sprite_palettes_data);
+ *bank = 0;
+ return &gb->sprite_palettes_data;
+ case GB_DIRECT_ACCESS_IE:
+ *size = sizeof(gb->interrupt_enable);
+ *bank = 0;
+ return &gb->interrupt_enable;
+ default:
+ *size = 0;
+ *bank = 0;
+ return NULL;
+ }
+}
+
+void GB_set_clock_multiplier(GB_gameboy_t *gb, double multiplier)
+{
+ gb->clock_multiplier = multiplier;
+ GB_apu_update_cycles_per_sample(gb);
+}
+
+uint32_t GB_get_clock_rate(GB_gameboy_t *gb)
+{
+ if (gb->model & GB_MODEL_PAL_BIT) {
+ return SGB_PAL_FREQUENCY * gb->clock_multiplier;
+ }
+ if ((gb->model & ~GB_MODEL_NO_SFC_BIT) == GB_MODEL_SGB) {
+ return SGB_NTSC_FREQUENCY * gb->clock_multiplier;
+ }
+ return CPU_FREQUENCY * gb->clock_multiplier;
+}
+
+void GB_set_border_mode(GB_gameboy_t *gb, GB_border_mode_t border_mode)
+{
+ if (gb->border_mode > GB_BORDER_ALWAYS) return;
+ gb->border_mode = border_mode;
+}
+
+unsigned GB_get_screen_width(GB_gameboy_t *gb)
+{
+ switch (gb->border_mode) {
+ default:
+ case GB_BORDER_SGB:
+ return GB_is_hle_sgb(gb)? 256 : 160;
+ case GB_BORDER_NEVER:
+ return 160;
+ case GB_BORDER_ALWAYS:
+ return 256;
+ }
+}
+
+unsigned GB_get_screen_height(GB_gameboy_t *gb)
+{
+ switch (gb->border_mode) {
+ default:
+ case GB_BORDER_SGB:
+ return GB_is_hle_sgb(gb)? 224 : 144;
+ case GB_BORDER_NEVER:
+ return 144;
+ case GB_BORDER_ALWAYS:
+ return 224;
+ }
+}
+
+unsigned GB_get_player_count(GB_gameboy_t *gb)
+{
+ return GB_is_hle_sgb(gb)? gb->sgb->player_count : 1;
+}
+
+void GB_set_update_input_hint_callback(GB_gameboy_t *gb, GB_update_input_hint_callback_t callback)
+{
+ gb->update_input_hint_callback = callback;
+}
+
+double GB_get_usual_frame_rate(GB_gameboy_t *gb)
+{
+ return GB_get_clock_rate(gb) / (double)LCDC_PERIOD;
+}
+
+void GB_set_joyp_write_callback(GB_gameboy_t *gb, GB_joyp_write_callback_t callback)
+{
+ gb->joyp_write_callback = callback;
+}
+
+void GB_set_icd_pixel_callback(GB_gameboy_t *gb, GB_icd_pixel_callback_t callback)
+{
+ gb->icd_pixel_callback = callback;
+}
+
+void GB_set_icd_hreset_callback(GB_gameboy_t *gb, GB_icd_hreset_callback_t callback)
+{
+ gb->icd_hreset_callback = callback;
+}
+
+
+void GB_set_icd_vreset_callback(GB_gameboy_t *gb, GB_icd_vreset_callback_t callback)
+{
+ gb->icd_vreset_callback = callback;
+}
+
+void GB_set_boot_rom_load_callback(GB_gameboy_t *gb, GB_boot_rom_load_callback_t callback)
+{
+ gb->boot_rom_load_callback = callback;
+ request_boot_rom(gb);
+}
+
+unsigned GB_time_to_alarm(GB_gameboy_t *gb)
+{
+ if (gb->cartridge_type->mbc_type != GB_HUC3) return 0;
+ if (!gb->huc3_alarm_enabled) return 0;
+ if (!(gb->huc3_alarm_days & 0x2000)) return 0;
+ unsigned current_time = (gb->huc3_days & 0x1FFF) * 24 * 60 * 60 + gb->huc3_minutes * 60 + (time(NULL) % 60);
+ unsigned alarm_time = (gb->huc3_alarm_days & 0x1FFF) * 24 * 60 * 60 + gb->huc3_alarm_minutes * 60;
+ if (current_time > alarm_time) return 0;
+ return alarm_time - current_time;
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/gb.h b/waterbox/bsnescore/bsnes/gb/Core/gb.h
new file mode 100644
index 0000000000..9043936851
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/gb.h
@@ -0,0 +1,816 @@
+#ifndef GB_h
+#define GB_h
+#define typeof __typeof__
+#include
+#include
+#include
+
+#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"
+#include "cheats.h"
+#include "rumble.h"
+#include "workboy.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__ >= 8
+#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
+
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
+#define __builtin_bswap16(x) ({ typeof(x) _x = (x); _x >> 8 | _x << 8; })
+#endif
+
+typedef struct {
+ struct {
+ uint8_t r, g, b;
+ } colors[5];
+} GB_palette_t;
+
+extern const GB_palette_t GB_PALETTE_GREY;
+extern const GB_palette_t GB_PALETTE_DMG;
+extern const GB_palette_t GB_PALETTE_MGB;
+extern const GB_palette_t GB_PALETTE_GBL;
+
+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_NTSC_NO_SFC = GB_MODEL_SGB | GB_MODEL_NO_SFC_BIT,
+ GB_MODEL_SGB_NO_SFC = GB_MODEL_SGB_NTSC_NO_SFC,
+ GB_MODEL_SGB_PAL_NO_SFC = GB_MODEL_SGB | GB_MODEL_NO_SFC_BIT | GB_MODEL_PAL_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_SUBTRACT_FLAG = 64,
+ GB_ZERO_FLAG = 128,
+};
+
+typedef enum {
+ GB_BORDER_SGB,
+ GB_BORDER_NEVER,
+ GB_BORDER_ALWAYS,
+} GB_border_mode_t;
+
+#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_KEY0 = 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_BANK = 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
+ GB_IO_OPRI = 0x6c, // Affects object priority (X based or index based)
+
+ /* 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;
+
+typedef enum {
+ GB_BOOT_ROM_DMG0,
+ GB_BOOT_ROM_DMG,
+ GB_BOOT_ROM_MGB,
+ GB_BOOT_ROM_SGB,
+ GB_BOOT_ROM_SGB2,
+ GB_BOOT_ROM_CGB0,
+ GB_BOOT_ROM_CGB,
+ GB_BOOT_ROM_AGB,
+} GB_boot_rom_t;
+
+#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, uint64_t cycles_since_last_update);
+typedef void (*GB_rumble_callback_t)(GB_gameboy_t *gb, double rumble_amplitude);
+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 void (*GB_boot_rom_load_callback_t)(GB_gameboy_t *gb, GB_boot_rom_t type);
+
+typedef struct {
+ bool state;
+ uint64_t 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. */
+
+#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
+ GB_workboy_t workboy;
+ );
+
+ /* 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:8;
+ uint8_t ram_bank:3;
+ } 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;
+ bool mode:1;
+ bool ir_mode:1;
+ } huc1;
+
+ struct {
+ uint8_t rom_bank:7;
+ uint8_t padding:1;
+ uint8_t ram_bank:4;
+ } huc3;
+ };
+ uint16_t mbc_rom0_bank; /* For some MBC1 wirings. */
+ bool camera_registers_mapped;
+ uint8_t camera_registers[0x36];
+ bool rumble_state;
+ bool cart_ir;
+
+ // TODO: move to huc3/mbc3 struct when breaking save compat
+ uint8_t huc3_mode;
+ uint8_t huc3_access_index;
+ uint16_t huc3_minutes, huc3_days;
+ uint16_t huc3_alarm_minutes, huc3_alarm_days;
+ bool huc3_alarm_enabled;
+ uint8_t huc3_read;
+ uint8_t huc3_access_flags;
+ bool mbc3_rtc_mapped;
+ );
+
+
+ /* 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 window_y;
+ /* 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 fifo_insertion_glitch;
+ 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 window_is_being_fetched;
+ bool wx166_glitch;
+ bool wx_triggered;
+ 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;
+ uint8_t object_priority;
+ bool oam_ppu_blocked;
+ bool vram_ppu_blocked;
+ bool cgb_palettes_ppu_blocked;
+ bool object_fetch_aborted;
+ bool during_object_fetch;
+ uint16_t object_low_line_address;
+ bool wy_triggered;
+ uint8_t window_tile_x;
+ uint8_t lcd_x; // The LCD can go out of sync since the push signal is skipped in some cases.
+ bool is_odd_frame;
+ uint16_t last_tile_data_address;
+ uint16_t last_tile_index_address;
+ bool cgb_repeated_a_frame;
+ );
+
+ /* 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;
+ bool is_mbc30;
+
+ 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];
+ const GB_palette_t *dmg_palette;
+ GB_color_correction_mode_t color_correction_mode;
+ bool keys[4][GB_KEY_MAX];
+ GB_border_mode_t border_mode;
+ GB_sgb_border_t borrowed_border;
+ bool tried_loading_sgb_border;
+ bool has_sgb_border;
+
+ /* 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;
+ GB_read_memory_callback_t read_memory_callback;
+ GB_boot_rom_load_callback_t boot_rom_load_callback;
+ GB_print_image_callback_t printer_callback;
+ GB_workboy_set_time_callback workboy_set_time_callback;
+ GB_workboy_get_time_callback workboy_get_time_callback;
+
+ /* IR */
+ uint64_t cycles_since_ir_change; // In 8MHz units
+ uint64_t 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, has_software_breakpoints;
+ void *nontrivial_jump_state;
+ bool non_trivial_jump_breakpoint_occured;
+
+ /* SLD (Todo: merge with backtrace) */
+ bool stack_leak_detection;
+ signed 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 */
+ uint64_t 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;
+
+ /* Cheats */
+ bool cheat_enabled;
+ size_t cheat_count;
+ GB_cheat_t **cheats;
+ GB_cheat_hash_t *cheat_hash[256];
+
+ /* 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;
+ GB_rumble_mode_t rumble_mode;
+ uint32_t rumble_on_cycles;
+ uint32_t rumble_off_cycles;
+
+ /* Temporary state */
+ bool wx_just_changed;
+ );
+};
+
+#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_load_isx(GB_gameboy_t *gb, const char *path);
+
+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_border_mode(GB_gameboy_t *gb, GB_border_mode_t border_mode);
+
+void GB_set_infrared_input(GB_gameboy_t *gb, bool state);
+void GB_queue_infrared_input(GB_gameboy_t *gb, bool state, uint64_t 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);
+/* Called when a new boot ROM is needed. The callback should call GB_load_boot_rom or GB_load_boot_rom_from_buffer */
+void GB_set_boot_rom_load_callback(GB_gameboy_t *gb, GB_boot_rom_load_callback_t callback);
+
+void GB_set_palette(GB_gameboy_t *gb, const GB_palette_t *palette);
+
+/* 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 cartridges with an alarm clock */
+unsigned GB_time_to_alarm(GB_gameboy_t *gb); // 0 if no alarm
+
+/* 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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/gb_struct_def.h b/waterbox/bsnescore/bsnes/gb/Core/gb_struct_def.h
new file mode 100644
index 0000000000..0e0ebd12ee
--- /dev/null
+++ b/waterbox/bsnescore/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
diff --git a/waterbox/bsnescore/bsnes/gb/Core/graphics/agb_border.inc b/waterbox/bsnescore/bsnes/gb/Core/graphics/agb_border.inc
new file mode 100644
index 0000000000..dd4ebbe88f
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/graphics/agb_border.inc
@@ -0,0 +1,522 @@
+static const uint16_t palette[] = {
+ 0x410A, 0x0421, 0x35AD, 0x4A52, 0x7FFF, 0x2D49, 0x0C42, 0x1484,
+ 0x18A5, 0x20C6, 0x6718, 0x5D6E, 0x0000, 0x0000, 0x0000, 0x0000,
+};
+
+static const uint16_t tilemap[] = {
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0001, 0x0002, 0x0003, 0x0003, 0x0003, 0x0004, 0x0004,
+ 0x0004, 0x0004, 0x0004, 0x0004, 0x0005, 0x0005, 0x0005, 0x0005,
+ 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004, 0x0004, 0x0004,
+ 0x0004, 0x0004, 0x0003, 0x0003, 0x0003, 0x4002, 0x4001, 0x0000,
+ 0x0000, 0x0006, 0x0007, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
+ 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
+ 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
+ 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x4007, 0x4006, 0x0000,
+ 0x0000, 0x0009, 0x0008, 0x0008, 0x0008, 0x000A, 0x000B, 0x000B,
+ 0x000B, 0x000B, 0x000B, 0x000B, 0x000B, 0x000B, 0x000B, 0x000B,
+ 0x000B, 0x000B, 0x000B, 0x000B, 0x000B, 0x000B, 0x000B, 0x000B,
+ 0x000B, 0x000B, 0x400A, 0x0008, 0x0008, 0x0008, 0xC009, 0x0000,
+ 0x0000, 0x000C, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x400C, 0x0000,
+ 0x0000, 0x000E, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC00E, 0x0000,
+ 0x0000, 0x000F, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x400F, 0x0000,
+ 0x0000, 0x0010, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC010, 0x0000,
+ 0x0000, 0x0010, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC010, 0x0000,
+ 0x0000, 0x0011, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC011, 0x0000,
+ 0x0000, 0x0011, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC011, 0x0000,
+ 0x0000, 0x0012, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x4012, 0x0000,
+ 0x0000, 0x0013, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC013, 0x0000,
+ 0x0014, 0x0015, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x4015, 0x4014,
+ 0x0016, 0x0017, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC017, 0xC016,
+ 0x0016, 0x0017, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC017, 0xC016,
+ 0x0018, 0x0019, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x4019, 0x4018,
+ 0x001A, 0x001B, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0xC01B, 0xC01A,
+ 0x001C, 0x001D, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x401D, 0x401C,
+ 0x001E, 0x0008, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x0008, 0xC01E,
+ 0x001E, 0x0008, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x0008, 0xC01E,
+ 0x001E, 0x0008, 0x0008, 0x0008, 0x0008, 0x000D, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC00D, 0x0008, 0x0008, 0x0008, 0x0008, 0xC01E,
+ 0x001F, 0x801D, 0x0008, 0x0008, 0x0008, 0x0020, 0x0021, 0x0022,
+ 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A,
+ 0x002B, 0x002C, 0x002D, 0x002D, 0x002D, 0x002D, 0x002D, 0x002D,
+ 0x002E, 0x0021, 0x4020, 0x0008, 0x0008, 0x0008, 0xC01D, 0x401F,
+ 0x002F, 0x0030, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0031,
+ 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039,
+ 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040, 0x0041,
+ 0x0042, 0x0043, 0x0008, 0x0008, 0x0008, 0x0008, 0x4030, 0x402F,
+ 0x0044, 0x0045, 0x0046, 0x0047, 0x0008, 0x0008, 0x0048, 0x0049,
+ 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051,
+ 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
+ 0x005A, 0x005B, 0x0008, 0x0008, 0x4047, 0x4046, 0x4045, 0x4044,
+ 0x0000, 0x0000, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060, 0x0061,
+ 0x0061, 0x0062, 0x0063, 0x0063, 0x0063, 0x0063, 0x0063, 0x0063,
+ 0x0063, 0x0063, 0x0063, 0x0063, 0x0063, 0x0063, 0x4062, 0x0061,
+ 0x0061, 0x4060, 0x405F, 0x405E, 0x405D, 0x405C, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+};
+
+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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x1F, 0x01,
+ 0x7F, 0x1F, 0xFF, 0x7E, 0xFF, 0xE1, 0xFF, 0x9F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x1E,
+ 0x1F, 0x60, 0x7F, 0x80, 0xFF, 0x00, 0xBF, 0x40,
+ 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x00, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x03, 0x01, 0x07, 0x03, 0x07, 0x03, 0x07, 0x06,
+ 0x07, 0x06, 0x07, 0x06, 0x07, 0x06, 0x07, 0x06,
+ 0x01, 0x02, 0x03, 0x04, 0x03, 0x04, 0x06, 0x01,
+ 0x06, 0x01, 0x06, 0x01, 0x06, 0x01, 0x06, 0x01,
+ 0xFF, 0xBF, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xBF, 0x40, 0x7F, 0x80, 0x7F, 0x80, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x0F, 0x0E, 0x0F, 0x0E, 0x0F, 0x0E, 0x0F, 0x0E,
+ 0x0F, 0x0E, 0x0F, 0x0E, 0x0F, 0x0E, 0x0F, 0x0E,
+ 0x0E, 0x01, 0x0E, 0x01, 0x0E, 0x01, 0x0E, 0x01,
+ 0x0E, 0x01, 0x0E, 0x01, 0x0E, 0x01, 0x0E, 0x01,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFE, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00,
+ 0x0F, 0x0E, 0x0F, 0x0E, 0x1F, 0x1B, 0x1F, 0x1B,
+ 0x1F, 0x1B, 0x1F, 0x1B, 0x1F, 0x1B, 0x1F, 0x1B,
+ 0x0E, 0x01, 0x0E, 0x01, 0x1B, 0x04, 0x1B, 0x04,
+ 0x1B, 0x04, 0x1B, 0x04, 0x1B, 0x04, 0x1B, 0x04,
+ 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,
+ 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,
+ 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00,
+ 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00,
+ 0x1F, 0x1B, 0x1F, 0x1B, 0x1F, 0x1B, 0x1F, 0x1B,
+ 0x1F, 0x1B, 0x1F, 0x1B, 0x1F, 0x1B, 0x1F, 0x1B,
+ 0x1B, 0x04, 0x1B, 0x04, 0x1B, 0x04, 0x1B, 0x04,
+ 0x1B, 0x04, 0x1B, 0x04, 0x1B, 0x04, 0x1B, 0x04,
+ 0x1F, 0x1B, 0x1F, 0x1B, 0x1F, 0x1B, 0x1F, 0x1B,
+ 0x1F, 0x1B, 0x3F, 0x37, 0x3F, 0x37, 0x3F, 0x37,
+ 0x1B, 0x04, 0x1B, 0x04, 0x1B, 0x04, 0x1B, 0x04,
+ 0x1B, 0x04, 0x37, 0x08, 0x37, 0x08, 0x37, 0x08,
+ 0x3F, 0x37, 0x3F, 0x37, 0x3F, 0x37, 0x3F, 0x37,
+ 0x3F, 0x37, 0x3F, 0x37, 0x3F, 0x37, 0x3F, 0x37,
+ 0x37, 0x08, 0x37, 0x08, 0x37, 0x08, 0x37, 0x08,
+ 0x37, 0x08, 0x37, 0x08, 0x37, 0x08, 0x37, 0x08,
+ 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F,
+ 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F,
+ 0x6F, 0x10, 0x6F, 0x10, 0x6F, 0x10, 0x6F, 0x10,
+ 0x6F, 0x10, 0x6F, 0x10, 0x6F, 0x10, 0x6F, 0x10,
+ 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0xFF, 0xDF,
+ 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF,
+ 0x6F, 0x10, 0x6F, 0x10, 0x6F, 0x10, 0xDF, 0x20,
+ 0xDF, 0x20, 0xDF, 0x20, 0xDF, 0x20, 0xDF, 0x20,
+ 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF,
+ 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF,
+ 0xDF, 0x20, 0xDF, 0x20, 0xDF, 0x20, 0xDF, 0x20,
+ 0xDF, 0x20, 0xDF, 0x20, 0xDF, 0x20, 0xDF, 0x20,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
+ 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xDF,
+ 0xFF, 0xDF, 0xFF, 0xDF, 0xFF, 0xBF, 0xFF, 0xBF,
+ 0xDF, 0x20, 0xDF, 0x20, 0xDF, 0x20, 0xDF, 0x20,
+ 0xDF, 0x20, 0xDF, 0x20, 0xBF, 0x40, 0xBF, 0x40,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
+ 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
+ 0xFF, 0xBF, 0xFF, 0xBF, 0xFF, 0xBF, 0xFF, 0xBF,
+ 0xFF, 0xBF, 0xFF, 0xBF, 0xFF, 0xBF, 0xFF, 0xBF,
+ 0xBF, 0x40, 0xBF, 0x40, 0xBF, 0x40, 0xBF, 0x40,
+ 0xBF, 0x40, 0xBF, 0x40, 0xBF, 0x40, 0xBF, 0x40,
+ 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00,
+ 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00,
+ 0xFF, 0xBF, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F,
+ 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F,
+ 0xBF, 0x40, 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80,
+ 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00,
+ 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00,
+ 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F,
+ 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F,
+ 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80,
+ 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x07, 0x06, 0x07, 0x06, 0x07, 0x06, 0x07, 0x06,
+ 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00,
+ 0x06, 0x01, 0x06, 0x01, 0x06, 0x01, 0x06, 0x01,
+ 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x07, 0x06, 0x07, 0x06, 0x07, 0x06, 0x07, 0x06,
+ 0x07, 0x06, 0x07, 0x06, 0x07, 0x06, 0x07, 0x06,
+ 0x06, 0x01, 0x06, 0x01, 0x06, 0x01, 0x06, 0x01,
+ 0x06, 0x01, 0x06, 0x01, 0x06, 0x01, 0x06, 0x01,
+ 0x07, 0x06, 0x07, 0x06, 0x07, 0x06, 0x07, 0x06,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x06, 0x01, 0x06, 0x01, 0x06, 0x01, 0x06, 0x01,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFE, 0x01, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xF8, 0xFF, 0xE7, 0xF8, 0xDF, 0xE3,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xF8, 0x00, 0xE4, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x3F, 0xFF, 0xCE, 0x3F, 0xF5, 0x8E,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x3F, 0x00, 0x4E, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x1F, 0xFF, 0xEE, 0x1F, 0xB5, 0x4E,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x1F, 0x00, 0x0E, 0xA0,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x07, 0xFF, 0xFB, 0x07, 0x04, 0x73,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x07, 0x00, 0x03, 0x88,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x80, 0xFF, 0x7F, 0x80, 0x82, 0x39,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x80, 0x00, 0x01, 0x44,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0xFE,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x83, 0x7C,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x42, 0x01,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFE, 0xFF, 0xBB, 0x7C, 0x4F, 0xB0,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x7C, 0x00, 0xB1, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x07, 0xFF, 0xF9, 0x06, 0xE7, 0xF8,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x06, 0x00, 0x08, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x0E, 0xFF, 0xF5, 0x0E, 0x9B, 0x74,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x0E, 0x00, 0x94, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x1F, 0xFF, 0xF7, 0x0F, 0xBF, 0x47,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x0F, 0x00, 0xA7, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0xFF,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x01, 0x02, 0x01, 0x02, 0x00, 0x01,
+ 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F,
+ 0xFF, 0x7F, 0xFF, 0xBF, 0xFF, 0xBF, 0xFF, 0xDF,
+ 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x80,
+ 0x7F, 0x80, 0xBF, 0x40, 0xBF, 0x40, 0xDF, 0x20,
+ 0xB0, 0xD8, 0xA0, 0xD3, 0x67, 0x84, 0x47, 0xA4,
+ 0x61, 0x81, 0xA0, 0xD0, 0xB4, 0xCA, 0x7E, 0x81,
+ 0xD7, 0x08, 0xCC, 0x13, 0x98, 0x20, 0x98, 0x00,
+ 0x9E, 0x20, 0xCF, 0x00, 0xCD, 0x02, 0x80, 0x01,
+ 0x32, 0x2D, 0x13, 0x6D, 0x34, 0x48, 0xFC, 0x02,
+ 0x7C, 0x00, 0x78, 0x05, 0x30, 0x49, 0x20, 0x50,
+ 0xCD, 0x00, 0xAC, 0x40, 0x49, 0x82, 0x01, 0x02,
+ 0x07, 0x80, 0xC2, 0x05, 0x86, 0x41, 0x9F, 0x40,
+ 0x15, 0x2E, 0x09, 0x06, 0x09, 0x16, 0x0B, 0xD4,
+ 0xC6, 0x49, 0x8E, 0x40, 0xCF, 0xC8, 0x06, 0x01,
+ 0xCE, 0x20, 0xE6, 0x10, 0xE6, 0x00, 0x24, 0xD0,
+ 0x39, 0x80, 0x38, 0x01, 0x31, 0x00, 0xF8, 0x00,
+ 0x0C, 0x8B, 0x85, 0x8A, 0x03, 0x84, 0x27, 0x20,
+ 0x22, 0x35, 0x12, 0x34, 0x20, 0x12, 0x10, 0x20,
+ 0x73, 0x00, 0x72, 0x08, 0x7C, 0x80, 0xDC, 0x01,
+ 0xC8, 0x11, 0xC9, 0x06, 0xCD, 0x22, 0xEF, 0x10,
+ 0x83, 0x44, 0x86, 0x01, 0x03, 0x85, 0x26, 0x21,
+ 0x46, 0x69, 0x46, 0x68, 0x8E, 0xCA, 0x86, 0x88,
+ 0x39, 0x40, 0x78, 0x84, 0x7C, 0x80, 0xD8, 0x01,
+ 0x90, 0x29, 0xD1, 0x28, 0x73, 0x00, 0xB3, 0x40,
+ 0x00, 0x01, 0x01, 0x00, 0x3F, 0x00, 0x3F, 0x40,
+ 0x03, 0x02, 0x01, 0x02, 0x41, 0x7C, 0x7F, 0x00,
+ 0xFE, 0x00, 0xFF, 0x00, 0xC0, 0x00, 0x80, 0x40,
+ 0xFC, 0x00, 0xFC, 0x00, 0x80, 0x02, 0xC0, 0x00,
+ 0xC0, 0x00, 0x80, 0x4C, 0xCC, 0x43, 0x8E, 0x52,
+ 0x80, 0x4C, 0x80, 0x00, 0x12, 0x1E, 0x9E, 0x00,
+ 0x7F, 0x00, 0x33, 0x0C, 0x32, 0x01, 0x23, 0x50,
+ 0x33, 0x4C, 0x7F, 0x00, 0x61, 0x80, 0xF1, 0x00,
+ 0x7C, 0x02, 0x30, 0x48, 0x31, 0x40, 0x61, 0x50,
+ 0x87, 0xE4, 0xE3, 0x84, 0x23, 0x44, 0x43, 0x44,
+ 0x85, 0x42, 0x87, 0x40, 0x8F, 0x50, 0x8C, 0x12,
+ 0x78, 0x00, 0x18, 0x20, 0xB8, 0x00, 0x98, 0x24,
+ 0x03, 0x04, 0x03, 0xE0, 0xF1, 0x12, 0xF0, 0x09,
+ 0xF9, 0x09, 0xF9, 0x08, 0xE1, 0x12, 0xF1, 0x12,
+ 0xF8, 0x00, 0x1E, 0xE0, 0x0C, 0x02, 0x07, 0x08,
+ 0x07, 0x00, 0x06, 0x00, 0x1C, 0x02, 0x0C, 0x00,
+ 0x9F, 0x91, 0x86, 0x88, 0xC4, 0x4C, 0x80, 0x4C,
+ 0xE1, 0x20, 0xC1, 0x22, 0x23, 0xD4, 0x22, 0xD5,
+ 0x60, 0x00, 0xFB, 0x00, 0x37, 0x00, 0x73, 0x0C,
+ 0x1F, 0x00, 0x3C, 0x00, 0xC8, 0x14, 0xC9, 0x14,
+ 0x16, 0x2F, 0x76, 0x4F, 0x2D, 0xDE, 0xDD, 0xBE,
+ 0xBA, 0x7D, 0x7A, 0xFD, 0x7A, 0xFD, 0xF4, 0xF8,
+ 0xCF, 0x00, 0x8F, 0x00, 0x5E, 0x80, 0xBE, 0x00,
+ 0x7D, 0x00, 0xFC, 0x00, 0xFC, 0x01, 0xF9, 0x02,
+ 0xFF, 0x00, 0xBF, 0x78, 0x86, 0x09, 0x86, 0x89,
+ 0x06, 0x25, 0x02, 0x25, 0x42, 0x45, 0x60, 0x11,
+ 0x00, 0x00, 0x09, 0x00, 0x70, 0x81, 0x70, 0x09,
+ 0xDC, 0x21, 0xD8, 0x01, 0x98, 0x25, 0xCC, 0x13,
+ 0xFF, 0x00, 0xF3, 0xF8, 0x02, 0x03, 0x01, 0x30,
+ 0x39, 0x09, 0x30, 0x09, 0x31, 0x09, 0x20, 0x19,
+ 0x00, 0x00, 0x01, 0x04, 0xFC, 0x00, 0xCF, 0x30,
+ 0xE6, 0x00, 0xE6, 0x01, 0xE6, 0x00, 0xF6, 0x08,
+ 0xFF, 0x00, 0xFA, 0xC7, 0x18, 0x21, 0x09, 0x10,
+ 0x88, 0x99, 0x93, 0x1A, 0x83, 0x11, 0xC2, 0x41,
+ 0x00, 0x00, 0x00, 0x20, 0xC6, 0x21, 0xFF, 0x00,
+ 0x67, 0x00, 0xE4, 0x08, 0x6F, 0x10, 0x3C, 0x00,
+ 0xFD, 0x02, 0xB5, 0x3A, 0xC7, 0x44, 0x03, 0x84,
+ 0x83, 0x24, 0x21, 0xB0, 0x21, 0x12, 0x21, 0x02,
+ 0x02, 0x00, 0x02, 0x40, 0x3C, 0x00, 0xF8, 0x00,
+ 0xD8, 0x24, 0x4C, 0x92, 0xEC, 0x00, 0xCC, 0x12,
+ 0xFF, 0x00, 0xFF, 0xF3, 0x1C, 0x14, 0x0C, 0x04,
+ 0x00, 0x0C, 0x04, 0x24, 0x00, 0x24, 0x10, 0x30,
+ 0x00, 0x00, 0x10, 0x04, 0xE3, 0x00, 0xFB, 0x00,
+ 0xF3, 0x08, 0xDB, 0x20, 0xDB, 0x04, 0xCF, 0x00,
+ 0xFF, 0x00, 0xEC, 0x3E, 0xC1, 0x01, 0x01, 0x8E,
+ 0x8F, 0x10, 0x0F, 0x90, 0x0F, 0x90, 0x0D, 0x09,
+ 0x00, 0x00, 0x20, 0x01, 0x7E, 0x00, 0xF1, 0x0E,
+ 0xE0, 0x10, 0x60, 0x10, 0x60, 0x10, 0x79, 0x82,
+ 0xFF, 0x00, 0x7F, 0xFC, 0x03, 0x82, 0x01, 0x9E,
+ 0x13, 0x80, 0x03, 0x80, 0x03, 0x9C, 0x0F, 0x90,
+ 0x00, 0x00, 0x02, 0x00, 0x7C, 0x80, 0x60, 0x9C,
+ 0x60, 0x9C, 0x7C, 0x80, 0x60, 0x9C, 0x70, 0x80,
+ 0xFF, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF,
+ 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xEF, 0xFF, 0xF7, 0x7F, 0x7B, 0x3F, 0x3C,
+ 0x1F, 0x1F, 0x0F, 0x0F, 0x03, 0x03, 0x00, 0x00,
+ 0xEF, 0x10, 0x77, 0x88, 0x3B, 0x44, 0x1C, 0x23,
+ 0x0F, 0x10, 0x03, 0x0C, 0x00, 0x03, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x3F, 0xFF, 0xC3, 0xFF, 0xFC, 0xFF, 0xFF,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x3F, 0xC0, 0xC3, 0x3C, 0xFC, 0x03, 0x3F, 0xC0,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xC1,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x3F, 0xC0, 0xC1, 0x3E,
+ 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xEA, 0x14, 0xC0, 0x00, 0x80, 0x21, 0x7F, 0x92,
+ 0x9F, 0xE0, 0xE3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x27, 0x18, 0x7F, 0x00, 0x1E, 0x61, 0x9A, 0x04,
+ 0xE0, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x73, 0x53, 0x47, 0x44, 0x46, 0x25, 0xFD, 0x03,
+ 0xF9, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x8C, 0x00, 0xD8, 0x20, 0x1D, 0xA0, 0x03, 0x00,
+ 0x07, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xC7, 0xE1, 0xE6, 0x05, 0x42, 0xA5, 0xBF, 0xC0,
+ 0x9F, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x18, 0x24, 0x38, 0x01, 0xB8, 0x05, 0xC0, 0x00,
+ 0xE0, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x21, 0x11, 0x31, 0x49, 0x33, 0x4A, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xDE, 0x00, 0x87, 0x48, 0x84, 0x48, 0x00, 0x00,
+ 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xCC, 0x02, 0x8E, 0x4A, 0xCC, 0x42, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x71, 0x08, 0x39, 0x00, 0x31, 0x02, 0x00, 0x00,
+ 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x3D, 0x40, 0x03, 0x02, 0x03, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xBC, 0x02, 0xFC, 0x00, 0xFE, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x12, 0x82, 0x80, 0x80, 0x01, 0x83, 0xFF, 0x00,
+ 0xFE, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x61, 0x1C, 0x7F, 0x00, 0x7C, 0x82, 0x00, 0x00,
+ 0x01, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x22, 0x52, 0x30, 0xC0, 0x58, 0xA4, 0x8F, 0x72,
+ 0x73, 0xFC, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x8C, 0x11, 0x4F, 0x90, 0xA3, 0x0C, 0x73, 0x00,
+ 0xFC, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x23, 0xA4, 0x06, 0x0D, 0x05, 0x1B, 0xBB, 0x07,
+ 0xE7, 0x1F, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x98, 0x44, 0xF5, 0x08, 0xEB, 0x00, 0x87, 0x40,
+ 0x1F, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x66, 0x85, 0xE2, 0xA5, 0x66, 0x81, 0xBF, 0xC1,
+ 0x99, 0xE7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x99, 0x00, 0xB9, 0x00, 0x9D, 0x20, 0xC1, 0x00,
+ 0xE7, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xF6, 0xFA, 0xFC, 0xF2, 0xF7, 0xF8, 0xFB, 0xFC,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xF9, 0x00, 0xF1, 0x02, 0xF8, 0x00, 0xFC, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x52, 0x53, 0x30, 0x23, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x8C, 0x21, 0xCC, 0x13, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x00, 0x03, 0x03, 0x06, 0xFE, 0x01, 0xF9, 0x07,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFD, 0x02, 0xFA, 0x04, 0x01, 0x00, 0x07, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x86, 0x05, 0x46, 0xA0, 0x5F, 0xB8, 0xBF, 0xC0,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x38, 0x41, 0x99, 0x26, 0xB8, 0x00, 0xC0, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x30, 0x28, 0x09, 0x09, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xC6, 0x09, 0xE6, 0x10, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x20, 0x38, 0x38, 0x20, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xD7, 0x08, 0xCF, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x80, 0x41, 0xA1, 0x61, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x3E, 0x40, 0x5E, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x01, 0x82, 0x01, 0x82, 0xFF, 0x00, 0xFC, 0x03,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x7C, 0x82, 0x7C, 0x82, 0x00, 0x00, 0x03, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x3F, 0x3F, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0x3C, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xFE, 0xFF, 0xFF, 0x3F, 0x3F, 0x01, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFE, 0x01, 0x3F, 0xC0, 0x01, 0x3E, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0x3F, 0xFF, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x3F, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x3F, 0xC0, 0xC0, 0x3F, 0xFF, 0x00, 0x3F, 0xC0,
+ 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xC0, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x3F, 0x3F, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0x00, 0x3F, 0xC0, 0xC0, 0x3F, 0xFF, 0x00,
+ 0x3F, 0xC0, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0xFF, 0xFC,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0x03, 0xFC, 0xFC, 0x03,
+ 0xFF, 0x00, 0x03, 0xFC, 0x00, 0x03, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF,
+ 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03,
+ 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x03,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x03, 0xFC,
+ 0xFC, 0x03, 0xFF, 0x00, 0x03, 0xFC, 0x00, 0x03,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF,
+};
diff --git a/waterbox/bsnescore/bsnes/gb/Core/graphics/cgb_border.inc b/waterbox/bsnescore/bsnes/gb/Core/graphics/cgb_border.inc
new file mode 100644
index 0000000000..755312a434
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/graphics/cgb_border.inc
@@ -0,0 +1,446 @@
+static const uint16_t palette[] = {
+ 0x7C1A, 0x0000, 0x0011, 0x3DEF, 0x6318, 0x7FFF, 0x1EBA, 0x19AF,
+ 0x1EAF, 0x4648, 0x7FC0, 0x2507, 0x1484, 0x5129, 0x5010, 0x2095,
+};
+
+static const uint16_t tilemap[] = {
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0001, 0x0002, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
+ 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
+ 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
+ 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x4002, 0x4001, 0x0000,
+ 0x0000, 0x0004, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005,
+ 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005,
+ 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005,
+ 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x4004, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0007, 0x0008, 0x0008,
+ 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
+ 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
+ 0x0008, 0x0008, 0x4007, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x000A, 0x000B, 0x400A, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x800A, 0x000C, 0xC00A, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x0006, 0x0005, 0x0005, 0x0005, 0x0009, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC009, 0x0005, 0x0005, 0x0005, 0xC006, 0x0000,
+ 0x0000, 0x000D, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x000E,
+ 0x000F, 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016,
+ 0x0017, 0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E,
+ 0x001F, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x400D, 0x0000,
+ 0x0000, 0x0020, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0021,
+ 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029,
+ 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030, 0x0031,
+ 0x0032, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x4020, 0x0000,
+ 0x0000, 0x0033, 0x0034, 0x0035, 0x0036, 0x0005, 0x0005, 0x0037,
+ 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+ 0x0040, 0x0005, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046,
+ 0x0047, 0x0005, 0x0005, 0x4036, 0x4035, 0x4034, 0x4033, 0x0000,
+ 0x0000, 0x0000, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D,
+ 0x004E, 0x004E, 0x004F, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050,
+ 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x404F, 0x004E, 0x004E,
+ 0x404D, 0x004C, 0x404B, 0x404A, 0x4049, 0x4048, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
+};
+
+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, 0x00, 0x00, 0x01, 0x00, 0x06, 0x00, 0x08,
+ 0x01, 0x11, 0x06, 0x26, 0x04, 0x24, 0x08, 0x48,
+ 0x00, 0x00, 0x01, 0x01, 0x07, 0x07, 0x0F, 0x0F,
+ 0x1E, 0x1F, 0x39, 0x3F, 0x3B, 0x3F, 0x77, 0x7F,
+ 0x00, 0x7F, 0x00, 0x80, 0x00, 0x00, 0x7F, 0x7F,
+ 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0xFF,
+ 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x08, 0x48, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x77, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F,
+ 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F,
+ 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+ 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
+ 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
+ 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+ 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x42,
+ 0xBD, 0xBD, 0x7E, 0x66, 0x7E, 0xFF, 0x7E, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBD, 0xFF,
+ 0x7E, 0xFF, 0xFF, 0xE7, 0x7E, 0x7E, 0x7E, 0x7E,
+ 0x7E, 0xFF, 0x3C, 0xFF, 0x81, 0xFF, 0xC3, 0xFF,
+ 0x7E, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x7E, 0x7E, 0x3C, 0x3C, 0x00, 0x00, 0x00, 0x81,
+ 0x81, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x08, 0x48, 0x08, 0x48, 0x08, 0x48, 0x08, 0x48,
+ 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F, 0x6F, 0x7F,
+ 0x37, 0x7F, 0x37, 0x7F, 0x37, 0x7F, 0x37, 0x7F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFE,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F, 0x3F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x70,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x8F, 0xDF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x78,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x87, 0xC7,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x3C,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC3, 0xE3,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9F, 0x9F,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x60, 0xE1,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD8, 0xD8,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x27, 0x8F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x70,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x8F, 0x8F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x70,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x8F, 0x9F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0xC2,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBD, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x3F,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xE0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0x84,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x7F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x08,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF,
+ 0x08, 0x48, 0x08, 0x48, 0x08, 0x48, 0x08, 0x48,
+ 0x08, 0x48, 0x04, 0x24, 0x04, 0x24, 0x02, 0x12,
+ 0x37, 0x7F, 0x37, 0x7F, 0x37, 0x7F, 0x37, 0x7F,
+ 0x37, 0x7F, 0x1B, 0x3F, 0x1B, 0x3F, 0x0D, 0x1F,
+ 0x0F, 0x08, 0x0E, 0x00, 0x1E, 0x12, 0x1E, 0x12,
+ 0x1F, 0x10, 0x0F, 0x08, 0x02, 0x02, 0x00, 0x00,
+ 0xF7, 0xF8, 0xFF, 0xF0, 0xED, 0xE3, 0xED, 0xE1,
+ 0xEF, 0xE0, 0xF7, 0xF0, 0xFD, 0xFC, 0xFF, 0xFF,
+ 0xF0, 0x10, 0x40, 0x00, 0x41, 0x41, 0x00, 0x00,
+ 0x83, 0x82, 0xE3, 0x20, 0xC7, 0x04, 0xC7, 0x00,
+ 0xEF, 0x1F, 0xFF, 0x1F, 0xBE, 0xFF, 0xFF, 0xFE,
+ 0x7D, 0x7E, 0xDF, 0x3C, 0xFB, 0x18, 0xFF, 0x18,
+ 0x60, 0x00, 0x70, 0x00, 0xF8, 0x08, 0xB0, 0x00,
+ 0xD8, 0x40, 0x3C, 0x24, 0x5C, 0x44, 0xFC, 0x00,
+ 0xFF, 0x8F, 0xFF, 0x0F, 0xF7, 0x07, 0xFF, 0x07,
+ 0xBF, 0x47, 0xDB, 0x47, 0xBB, 0x03, 0xFF, 0x03,
+ 0x3C, 0x04, 0x78, 0x00, 0x78, 0x00, 0xEC, 0x80,
+ 0xFE, 0x92, 0xE7, 0x83, 0xE5, 0x80, 0x4F, 0x08,
+ 0xFB, 0x83, 0xFF, 0x83, 0xFF, 0x83, 0x7F, 0x83,
+ 0x6D, 0x93, 0x7C, 0x10, 0x7F, 0x10, 0xF7, 0x10,
+ 0x3C, 0x00, 0x7C, 0x40, 0x78, 0x00, 0xC8, 0x80,
+ 0xFC, 0x24, 0xBC, 0x24, 0xFD, 0x65, 0x3D, 0x25,
+ 0xFF, 0xC3, 0xBF, 0x83, 0xFF, 0x83, 0x7F, 0x03,
+ 0xDB, 0x23, 0xDB, 0x23, 0x9A, 0x67, 0xDA, 0x47,
+ 0xFF, 0x80, 0xFF, 0x80, 0xE0, 0x80, 0x40, 0x00,
+ 0xFF, 0x01, 0xFF, 0x01, 0xDF, 0x1F, 0xE0, 0x20,
+ 0x7F, 0x80, 0x7F, 0x00, 0x7F, 0x1F, 0xFF, 0x1F,
+ 0xFE, 0x00, 0xFE, 0x00, 0xE0, 0x01, 0xDF, 0x3F,
+ 0xBF, 0xA0, 0xB9, 0xA0, 0x10, 0x00, 0x11, 0x01,
+ 0x3B, 0x00, 0x3F, 0x00, 0x7E, 0x4E, 0x78, 0x48,
+ 0x5F, 0x40, 0x5F, 0xC0, 0xFF, 0xC7, 0xFE, 0xC7,
+ 0xFF, 0xC0, 0xFF, 0xC0, 0xB1, 0xC4, 0xB7, 0x8F,
+ 0xE3, 0x22, 0xC7, 0x04, 0xCE, 0x08, 0xE6, 0x20,
+ 0xCE, 0x42, 0xDE, 0x52, 0xFE, 0x32, 0xFC, 0x30,
+ 0xDD, 0x3E, 0xFB, 0x18, 0xF7, 0x18, 0xDF, 0x31,
+ 0xBD, 0x31, 0xAD, 0x23, 0xCD, 0x31, 0xCF, 0x11,
+ 0xFE, 0x02, 0x9E, 0x00, 0x86, 0x80, 0x06, 0x00,
+ 0x03, 0x00, 0x02, 0x00, 0x07, 0x01, 0x07, 0x01,
+ 0xFD, 0x03, 0xFF, 0x01, 0x7F, 0xF0, 0xFF, 0xF8,
+ 0xFF, 0xF8, 0xFF, 0xF8, 0xFE, 0xF8, 0xFE, 0xF1,
+ 0x38, 0x08, 0x71, 0x41, 0x1F, 0x06, 0x39, 0x20,
+ 0x0F, 0x00, 0x0F, 0x01, 0x04, 0x00, 0x0C, 0x00,
+ 0xF7, 0x87, 0xBE, 0xC6, 0xF9, 0xC6, 0xDF, 0xE0,
+ 0xFF, 0xE0, 0xFE, 0xF1, 0xFF, 0xF1, 0xFF, 0xF1,
+ 0x70, 0x10, 0xE0, 0x20, 0x80, 0x00, 0x80, 0x00,
+ 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xEF, 0x1F, 0xDF, 0x1F, 0xFF, 0x3F, 0xFF, 0x7F,
+ 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x3F, 0x3F, 0x7F, 0x7F, 0x78, 0x78, 0xF0, 0xF0,
+ 0xF0, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xF0, 0xF0,
+ 0xDF, 0xFF, 0xBD, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF,
+ 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xFF,
+ 0xE7, 0xE0, 0xFF, 0xF0, 0xFE, 0xF0, 0x1C, 0x00,
+ 0x3C, 0x20, 0x3C, 0x24, 0x3C, 0x24, 0x3C, 0x20,
+ 0xFF, 0xFF, 0xEF, 0xFF, 0x6F, 0xFF, 0xFF, 0xFF,
+ 0xDF, 0xFF, 0xDB, 0xFF, 0xDB, 0xFF, 0xDF, 0xFF,
+ 0xF8, 0x00, 0xFC, 0xC0, 0x1F, 0x03, 0x1F, 0x13,
+ 0x1F, 0x13, 0x1E, 0x02, 0x1E, 0x02, 0x3E, 0x02,
+ 0xFF, 0xFF, 0x3F, 0xFF, 0xFC, 0xFF, 0xEC, 0xFF,
+ 0xED, 0xFE, 0xFC, 0xFF, 0xFC, 0xFF, 0xFC, 0xFF,
+ 0x90, 0x90, 0x00, 0x00, 0x00, 0x00, 0x21, 0x21,
+ 0x20, 0x21, 0x00, 0x01, 0x00, 0x01, 0x40, 0x41,
+ 0x8F, 0x7F, 0x1F, 0xFF, 0x1F, 0xFF, 0x3F, 0xDE,
+ 0x1F, 0xFE, 0x3F, 0xFE, 0x3F, 0xFE, 0x7F, 0xBE,
+ 0x40, 0x7F, 0x84, 0xFF, 0x11, 0xF1, 0x20, 0xE0,
+ 0x20, 0xE0, 0x01, 0xC1, 0x01, 0xC1, 0x22, 0xE3,
+ 0xFF, 0x80, 0xFF, 0x00, 0xFF, 0x0E, 0xFF, 0x1F,
+ 0xDF, 0x3F, 0xFE, 0x3F, 0xFF, 0x3E, 0xFD, 0x1E,
+ 0x47, 0xC0, 0x27, 0xE0, 0x2F, 0xE8, 0x0F, 0xE9,
+ 0x0F, 0xE1, 0x0F, 0xE0, 0x3F, 0xF0, 0x3F, 0xF1,
+ 0xF8, 0x3F, 0xF8, 0x1F, 0xF0, 0x1F, 0xF0, 0x1F,
+ 0xF0, 0x1F, 0xF0, 0x1F, 0xE0, 0x1F, 0xC0, 0x3F,
+ 0xFC, 0x00, 0xFE, 0xE2, 0x1E, 0x12, 0x1E, 0x12,
+ 0x3E, 0x22, 0xFC, 0x00, 0xF8, 0x08, 0xF0, 0x10,
+ 0x03, 0xFF, 0x01, 0xFF, 0xE1, 0xFF, 0xE1, 0xFF,
+ 0xC1, 0xFF, 0x03, 0xFF, 0x07, 0xFF, 0x0F, 0xFF,
+ 0x01, 0x11, 0x00, 0x08, 0x00, 0x04, 0x00, 0x02,
+ 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x0E, 0x1F, 0x07, 0x0F, 0x03, 0x07, 0x01, 0x03,
+ 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x80, 0x80, 0x40, 0x40, 0x30, 0x30,
+ 0x0C, 0x0C, 0x03, 0xC3, 0x00, 0x30, 0x00, 0x0C,
+ 0xFF, 0xFF, 0x7F, 0xFF, 0xBF, 0xFF, 0xCF, 0xFF,
+ 0xF3, 0xFF, 0x3C, 0xFF, 0x0F, 0x3F, 0x03, 0x0F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xC0, 0xC0, 0x3C, 0x3C, 0x03, 0x03,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x3F, 0xFF, 0xC3, 0xFF, 0xFC, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xE0,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xFF,
+ 0x15, 0x15, 0x3F, 0x20, 0x2F, 0x20, 0x06, 0x06,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xEA, 0xE6, 0xDF, 0xC0, 0xDF, 0xE0, 0xF9, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xE6, 0x20, 0x9E, 0x12, 0x0C, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xDF, 0x30, 0xED, 0x31, 0xFF, 0x63, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x0E, 0x02, 0x1E, 0x12, 0x0D, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFD, 0x03, 0xED, 0xE1, 0xFE, 0xF1, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x4F, 0x08, 0xE6, 0x20, 0xE7, 0x21, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xF7, 0x18, 0xDF, 0x18, 0xDE, 0x18, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xB9, 0xA1, 0x11, 0x01, 0x10, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x5E, 0x46, 0xFE, 0xC6, 0xFF, 0xC6, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x3F, 0xFF, 0x01, 0xFF, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC0, 0x01, 0xFE, 0x00, 0xFE, 0x00, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x7E, 0x4E, 0x3F, 0x00, 0x3E, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xB1, 0x8E, 0xFF, 0x80, 0xFF, 0x80, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xEE, 0x20, 0x8F, 0x08, 0x85, 0x84, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xDF, 0x30, 0xF7, 0x38, 0x7B, 0x7C, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xAE, 0xA2, 0xF8, 0x00, 0xE8, 0x08, 0xC0, 0xC0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x5D, 0xE1, 0xFF, 0x03, 0xF7, 0x0F, 0x3F, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x0E, 0x02, 0x1E, 0x12, 0x1E, 0x12, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFD, 0xF1, 0xED, 0xF1, 0xED, 0xE3, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFB, 0xFB, 0x7F, 0x7F, 0x3F, 0x3F, 0x0C, 0x0C,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x75, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF3, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xDF, 0xC1, 0xDF, 0xD0, 0x8F, 0x88, 0x01, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFE, 0xFF, 0xEF, 0xFF, 0x77, 0xFF, 0xFE, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFA, 0x82, 0xF8, 0x08, 0xE0, 0x00, 0x81, 0x81,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x7E, 0xFD, 0xF4, 0xFF, 0xFC, 0xFF, 0x7E, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x7D, 0x7D, 0x02, 0x02, 0x02, 0x02, 0xFC, 0xFC,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0xFE, 0x01, 0xFF, 0x01, 0xFF, 0x03, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x1C, 0xFF, 0x00, 0xFF, 0x41, 0x7F, 0x18, 0x18,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xF7, 0x08, 0xFF, 0x00, 0xFF, 0x80, 0xE7, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x5E, 0xC2, 0x9C, 0x80, 0x1C, 0x04, 0x08, 0x08,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xE1, 0x3F, 0xE3, 0x7F, 0xE3, 0xFF, 0xF7, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xF0, 0x80, 0x78, 0x08, 0x78, 0x48, 0x10, 0x10,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x0F, 0xFF, 0x87, 0xFF, 0x87, 0xFF, 0xEF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0xC0, 0x00, 0x3C, 0x00, 0x03, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x3F, 0xFF, 0x03, 0x3F, 0x00, 0x03, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x1C, 0x1C, 0x03, 0x03, 0x00, 0xE0, 0x00, 0x1C,
+ 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xE3, 0xFF, 0xFC, 0xFF, 0x1F, 0xFF, 0x03, 0x1F,
+ 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xFC, 0xFC, 0x03, 0x03, 0x00, 0x00,
+ 0x00, 0xFC, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xFF, 0x03, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF,
+ 0x03, 0xFF, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x3F, 0x3F,
+ 0x00, 0x00, 0x00, 0xC0, 0x00, 0x3F, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xC0, 0xFF,
+ 0xFF, 0xFF, 0x3F, 0xFF, 0x00, 0x3F, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0,
+ 0x3F, 0x3F, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x3F,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF,
+ 0xC0, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0x00, 0x3F,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF
+};
diff --git a/waterbox/bsnescore/bsnes/gb/Core/graphics/dmg_border.inc b/waterbox/bsnescore/bsnes/gb/Core/graphics/dmg_border.inc
new file mode 100644
index 0000000000..7db0673a4d
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/graphics/dmg_border.inc
@@ -0,0 +1,558 @@
+static const uint16_t palette[] = {
+ 0x0000, 0x0011, 0x18C6, 0x001A, 0x318C, 0x39CE, 0x5294, 0x5AD6,
+ 0x739C, 0x45A8, 0x4520, 0x18A5, 0x4A32, 0x2033, 0x20EC, 0x0000,
+};
+
+static const uint16_t tilemap[] = {
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0001, 0x0003, 0x0004, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005,
+ 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005,
+ 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005,
+ 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x4004, 0x4003, 0x0001,
+ 0x0001, 0x0006, 0x0007, 0x0007, 0x0007, 0x0008, 0x0009, 0x000A,
+ 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010, 0x0011, 0x0012,
+ 0x0013, 0x0014, 0x0015, 0x000E, 0x0016, 0x0017, 0x0018, 0x0019,
+ 0x001A, 0x001B, 0x001C, 0x0007, 0x0007, 0x0007, 0x4006, 0x0001,
+ 0x0001, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x0020, 0x0021,
+ 0x0022, 0x0023, 0x0024, 0x0025, 0x4024, 0x0026, 0x0025, 0x0025,
+ 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E,
+ 0x002F, 0x0030, 0x0031, 0x001E, 0x001E, 0x001E, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0034, 0x0035, 0x4034, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x8034, 0x0036, 0xC034, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0xC01D, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0x0037, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0032, 0x0038, 0x0001,
+ 0x0001, 0x001D, 0x0032, 0x0032, 0x0032, 0x0033, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0xC033, 0x0032, 0x0032, 0x0039, 0x003A, 0x0001,
+ 0x0001, 0x003B, 0x003C, 0x0032, 0x0032, 0xC03C, 0x003D, 0x003D,
+ 0x003D, 0x003D, 0x003D, 0x003D, 0x003D, 0x003D, 0x003D, 0x003D,
+ 0x003D, 0x003D, 0x003D, 0x003D, 0x003D, 0x003D, 0x003D, 0x003D,
+ 0x003D, 0x003D, 0x003E, 0x003F, 0x0040, 0x0041, 0x0001, 0x0001,
+ 0x0001, 0x0042, 0x0043, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044,
+ 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044,
+ 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044,
+ 0x0044, 0x0044, 0x0045, 0x0046, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D,
+ 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x005B,
+ 0x005C, 0x005D, 0x005E, 0x005F, 0x0060, 0x0061, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+ 0x0068, 0x0069, 0x006A, 0x006B, 0x0001, 0x006C, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+};
+
+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,
+ 0x00, 0xFF, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01,
+ 0x00, 0xFF, 0x00, 0xFF, 0x21, 0xDE, 0x00, 0x7F,
+ 0x0C, 0xF3, 0x19, 0xE0, 0x10, 0xEE, 0x08, 0xF7,
+ 0xFF, 0x00, 0xFF, 0x00, 0xC0, 0x3F, 0x80, 0xFF,
+ 0x00, 0xFF, 0x0E, 0xF7, 0x1F, 0xE1, 0x07, 0xF8,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x7F, 0x00, 0xBF,
+ 0x40, 0xBE, 0x80, 0x3F, 0x02, 0xFD, 0x00, 0xFB,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x80, 0x7F, 0xC0,
+ 0x7F, 0x81, 0xFE, 0x41, 0xFC, 0x03, 0xFC, 0x07,
+ 0x00, 0xFF, 0x00, 0xFF, 0x08, 0xF7, 0x00, 0xFF,
+ 0x00, 0xFB, 0x04, 0xFB, 0x24, 0xDB, 0x64, 0x9B,
+ 0xFF, 0x00, 0xFF, 0x00, 0x87, 0x78, 0x07, 0xF8,
+ 0x07, 0xFC, 0x07, 0xF8, 0x03, 0xFC, 0x43, 0xBC,
+ 0x00, 0xFF, 0x00, 0xFF, 0x01, 0xDE, 0x20, 0xDF,
+ 0x20, 0xDF, 0x00, 0xFF, 0x04, 0xFB, 0x04, 0xFB,
+ 0xFF, 0x00, 0xFF, 0x00, 0xE0, 0x3F, 0xC0, 0x3F,
+ 0xC0, 0x3F, 0xC0, 0x3F, 0xC0, 0x3F, 0xC0, 0x3F,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFB, 0x00, 0xFF,
+ 0x00, 0x77, 0x00, 0x7F, 0x80, 0x6F, 0x82, 0x7D,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFC, 0x07, 0xF8, 0x07,
+ 0xF8, 0x8F, 0xF0, 0x8F, 0x70, 0x9F, 0x60, 0x9F,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFB, 0x24, 0xCB,
+ 0x24, 0xDB, 0x20, 0xDF, 0x20, 0xDF, 0x00, 0xDF,
+ 0xFF, 0x00, 0xFF, 0x00, 0x1C, 0xE7, 0x18, 0xF7,
+ 0x18, 0xE7, 0x18, 0xE7, 0x38, 0xC7, 0x38, 0xE7,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x02, 0xFC,
+ 0x7E, 0x81, 0x80, 0x01, 0x80, 0x7F, 0xF8, 0x03,
+ 0xFF, 0x00, 0xFF, 0x00, 0x01, 0xFE, 0x01, 0xFF,
+ 0x01, 0xFE, 0x7F, 0xFE, 0x7F, 0x80, 0x07, 0xFC,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xBF, 0x40, 0xBF,
+ 0x47, 0xB8, 0x08, 0xF0, 0x08, 0xF7, 0x0E, 0xF1,
+ 0xFF, 0x00, 0xFF, 0x00, 0xC0, 0x7F, 0x80, 0x7F,
+ 0x80, 0x7F, 0x87, 0x7F, 0x87, 0x78, 0x80, 0x7F,
+ 0x00, 0xFF, 0x00, 0xFF, 0x40, 0x9F, 0x00, 0xFF,
+ 0x10, 0xEF, 0x90, 0x6F, 0x10, 0xEB, 0x14, 0xEB,
+ 0xFF, 0x00, 0xFF, 0x00, 0x3F, 0xE0, 0x1F, 0xE0,
+ 0x0E, 0xF1, 0x0C, 0xF3, 0x0C, 0xF7, 0x18, 0xE7,
+ 0x00, 0xFF, 0x00, 0xFF, 0x20, 0x9F, 0x00, 0xFF,
+ 0x0C, 0xF3, 0x31, 0xC0, 0x60, 0x9F, 0x40, 0xBF,
+ 0xFF, 0x00, 0xFF, 0x00, 0xC0, 0x7F, 0x00, 0xFF,
+ 0x00, 0xFF, 0x1E, 0xEF, 0x3F, 0xC0, 0x7F, 0x80,
+ 0x00, 0xFF, 0x00, 0xFF, 0x80, 0x77, 0x04, 0xDB,
+ 0x00, 0xFB, 0x10, 0xEF, 0x00, 0xFD, 0x80, 0x77,
+ 0xFF, 0x00, 0xFF, 0x00, 0x78, 0x8F, 0x38, 0xE7,
+ 0x1C, 0xE7, 0x0C, 0xF3, 0x0E, 0xF3, 0x0E, 0xF9,
+ 0x00, 0xFF, 0x00, 0xFF, 0x80, 0x7F, 0x00, 0xFF,
+ 0x40, 0xB7, 0x00, 0xEF, 0x01, 0xDE, 0x02, 0xFC,
+ 0xFF, 0x00, 0xFF, 0x00, 0x7C, 0x83, 0x78, 0x87,
+ 0x38, 0xCF, 0x30, 0xDF, 0x21, 0xFE, 0x03, 0xFD,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xDF, 0x60, 0x9F,
+ 0xC0, 0x3F, 0x80, 0x7F, 0x00, 0x7F, 0x00, 0xFF,
+ 0xFF, 0x00, 0xFF, 0x00, 0x3F, 0xE0, 0x3F, 0xC0,
+ 0x7F, 0x80, 0xFF, 0x00, 0xFF, 0x80, 0xFF, 0x00,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFB, 0x01, 0xFC,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFE, 0x01, 0xFC, 0x03, 0xFC, 0x07, 0xFE, 0x03,
+ 0x00, 0xFF, 0x40, 0x3F, 0x30, 0x8F, 0x00, 0xF7,
+ 0x80, 0x7F, 0x30, 0xCF, 0x01, 0xFE, 0x87, 0x78,
+ 0x01, 0xFE, 0x80, 0xFF, 0xE0, 0x5F, 0xF8, 0x0F,
+ 0x78, 0x87, 0x00, 0xFF, 0x00, 0xFF, 0x03, 0xFC,
+ 0x00, 0xFF, 0x08, 0xF7, 0x80, 0x6F, 0x80, 0x7F,
+ 0x80, 0x5F, 0x87, 0x78, 0x04, 0x7B, 0x08, 0x73,
+ 0xF8, 0x07, 0xF0, 0x0F, 0x70, 0x9F, 0x60, 0x9F,
+ 0x60, 0xBF, 0xC3, 0x3C, 0x87, 0xF8, 0x87, 0xFC,
+ 0xA0, 0x1F, 0x80, 0x7D, 0xE2, 0x1D, 0x02, 0xFD,
+ 0x02, 0xFD, 0xF0, 0x0F, 0x10, 0xEE, 0x11, 0xEE,
+ 0x43, 0xFC, 0xE3, 0x1E, 0x03, 0xFC, 0x01, 0xFE,
+ 0x01, 0xFE, 0xE1, 0x1E, 0xE1, 0x1F, 0xE1, 0x1E,
+ 0x44, 0xBB, 0x48, 0xB3, 0x48, 0xB7, 0x08, 0xF7,
+ 0x0A, 0xF5, 0x02, 0xF5, 0x80, 0x77, 0x90, 0x67,
+ 0x84, 0x7B, 0x84, 0x7F, 0x84, 0x7B, 0x84, 0x7B,
+ 0x8C, 0x73, 0x8C, 0x7B, 0x0E, 0xF9, 0x0E, 0xF9,
+ 0x86, 0x59, 0x06, 0xF9, 0x48, 0xB3, 0x08, 0xF7,
+ 0x10, 0xE7, 0x14, 0xEB, 0x24, 0xCB, 0x20, 0xDF,
+ 0x60, 0xBF, 0x44, 0xBB, 0x04, 0xFF, 0x0C, 0xF3,
+ 0x0C, 0xFB, 0x18, 0xE7, 0x18, 0xF7, 0x38, 0xC7,
+ 0x08, 0xD7, 0x48, 0x97, 0x48, 0xB7, 0x41, 0xBE,
+ 0x41, 0xBE, 0x01, 0xBE, 0x10, 0xAF, 0x90, 0x2F,
+ 0x30, 0xEF, 0x30, 0xEF, 0x30, 0xCF, 0x30, 0xCF,
+ 0x70, 0x8F, 0x70, 0xCF, 0x60, 0xDF, 0x60, 0xDF,
+ 0x04, 0xFB, 0x04, 0xFB, 0xFC, 0x03, 0x00, 0xFF,
+ 0x00, 0xFF, 0xF8, 0x02, 0x05, 0xFA, 0x05, 0xFA,
+ 0x03, 0xFC, 0x03, 0xFC, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0x07, 0xFD, 0x02, 0xFD, 0x06, 0xF9,
+ 0x80, 0x7F, 0x80, 0x7F, 0x0F, 0xF0, 0x10, 0xE7,
+ 0x10, 0xEE, 0x1E, 0xE1, 0x00, 0xFF, 0x00, 0xFF,
+ 0x00, 0xFF, 0x00, 0xFF, 0x0E, 0xF1, 0x0F, 0xF8,
+ 0x0F, 0xF1, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0x60, 0x8F, 0x00, 0xDF, 0x00, 0xFF, 0x00, 0xEF,
+ 0x04, 0xEB, 0x20, 0xCF, 0x22, 0xDD, 0xC1, 0x1E,
+ 0x38, 0xD7, 0x38, 0xE7, 0x18, 0xE7, 0x18, 0xF7,
+ 0x18, 0xF7, 0x1C, 0xF3, 0x3E, 0xC1, 0x7F, 0xA0,
+ 0x80, 0x3F, 0x80, 0x7F, 0x80, 0x7F, 0x01, 0xFE,
+ 0x00, 0xBD, 0x18, 0xE7, 0x00, 0xFF, 0x83, 0x7C,
+ 0x7F, 0xC0, 0x7F, 0x80, 0x7F, 0x80, 0x7E, 0x81,
+ 0x7E, 0xC3, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0x81, 0x76, 0x80, 0x77, 0x10, 0xE7, 0x10, 0xEF,
+ 0x10, 0xEF, 0x21, 0xCE, 0x41, 0x9E, 0x81, 0x3E,
+ 0x0E, 0xF9, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF0,
+ 0x1F, 0xE0, 0x3E, 0xD1, 0x7E, 0xA1, 0xFE, 0x41,
+ 0x04, 0xF9, 0x08, 0xF3, 0x18, 0xE7, 0x10, 0xEF,
+ 0x10, 0xEF, 0x10, 0xEF, 0x00, 0xEF, 0x20, 0xCF,
+ 0x07, 0xFA, 0x07, 0xFC, 0x0F, 0xF0, 0x0F, 0xF0,
+ 0x0F, 0xF0, 0x1F, 0xE0, 0x1F, 0xF0, 0x1F, 0xF0,
+ 0x7C, 0x01, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0xFF, 0x82, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x78, 0x87, 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,
+ 0x0F, 0xF0, 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,
+ 0x70, 0x8E, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0xFF, 0x01, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xC3, 0x18, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0xFF, 0x24, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x8F, 0x70, 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,
+ 0xF8, 0x03, 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,
+ 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,
+ 0x00, 0x7F, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0xFF, 0x80, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0x3E, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
+ 0xFF, 0xC1, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
+ 0xE0, 0x1F, 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,
+};
diff --git a/waterbox/bsnescore/bsnes/gb/Core/graphics/sgb_animation_logo.inc b/waterbox/bsnescore/bsnes/gb/Core/graphics/sgb_animation_logo.inc
new file mode 100644
index 0000000000..75075f4921
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/graphics/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;
diff --git a/waterbox/bsnescore/bsnes/gb/Core/graphics/sgb_border.inc b/waterbox/bsnescore/bsnes/gb/Core/graphics/sgb_border.inc
new file mode 100644
index 0000000000..d7d0a5c980
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/graphics/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
+};
diff --git a/waterbox/bsnescore/bsnes/gb/Core/joypad.c b/waterbox/bsnescore/bsnes/gb/Core/joypad.c
new file mode 100644
index 0000000000..b8d4fdb475
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/joypad.c
@@ -0,0 +1,92 @@
+#include "gb.h"
+#include
+
+void GB_update_joyp(GB_gameboy_t *gb)
+{
+ if (gb->model & GB_MODEL_NO_SFC_BIT) 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 & (gb->sgb->player_count - 1) & 3) : 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;
+ }
+ gb->io_registers[GB_IO_JOYP] |= 0xC0;
+}
+
+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);
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/joypad.h b/waterbox/bsnescore/bsnes/gb/Core/joypad.h
new file mode 100644
index 0000000000..21fad5343f
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/joypad.h
@@ -0,0 +1,25 @@
+#ifndef joypad_h
+#define joypad_h
+#include "gb_struct_def.h"
+#include
+
+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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/mbc.c b/waterbox/bsnescore/bsnes/gb/Core/mbc.c
new file mode 100644
index 0000000000..225968178d
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/mbc.c
@@ -0,0 +1,167 @@
+#include
+#include
+#include
+#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 , true, false}, // FEh HuC3
+ { GB_HUC1 , GB_STANDARD_MBC, true , true , false, false}, // FFh HuC1+RAM+BATTERY
+};
+
+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->is_mbc30) {
+ gb->mbc_rom_bank &= 0x7F;
+ }
+ 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 unsigned ram_sizes[256] = {0, 0x800, 0x2000, 0x8000, 0x20000, 0x10000};
+ gb->mbc_ram_size = ram_sizes[gb->rom[0x149]];
+ }
+
+ if (gb->mbc_ram_size) {
+ 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;
+ }
+ }
+
+ /* Detect MBC30 */
+ if (gb->cartridge_type->mbc_type == GB_MBC3) {
+ if (gb->rom_size > 0x200000 || gb->mbc_ram_size > 0x8000) {
+ gb->is_mbc30 = true;
+ }
+ }
+
+ /* Set MBC5's bank to 1 correctly */
+ if (gb->cartridge_type->mbc_type == GB_MBC5) {
+ gb->mbc5.rom_bank_low = 1;
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/mbc.h b/waterbox/bsnescore/bsnes/gb/Core/mbc.h
new file mode 100644
index 0000000000..6a23300f52
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/mbc.h
@@ -0,0 +1,32 @@
+#ifndef MBC_h
+#define MBC_h
+#include "gb_struct_def.h"
+#include
+
+typedef struct {
+ enum {
+ GB_NO_MBC,
+ GB_MBC1,
+ GB_MBC2,
+ GB_MBC3,
+ GB_MBC5,
+ GB_HUC1,
+ 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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/memory.c b/waterbox/bsnescore/bsnes/gb/Core/memory.c
new file mode 100644
index 0000000000..f73209e3fe
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/memory.c
@@ -0,0 +1,1213 @@
+#include
+#include
+#include "gb.h"
+
+typedef uint8_t GB_read_function_t(GB_gameboy_t *gb, uint16_t addr);
+typedef void GB_write_function_t(GB_gameboy_t *gb, uint16_t addr, uint8_t value);
+
+typedef enum {
+ GB_BUS_MAIN, /* In DMG: Cart and RAM. In CGB: Cart only */
+ GB_BUS_RAM, /* In CGB only. */
+ GB_BUS_VRAM,
+ GB_BUS_INTERNAL, /* Anything in highram. Might not be the most correct name. */
+} GB_bus_t;
+
+static GB_bus_t bus_for_addr(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (addr < 0x8000) {
+ return GB_BUS_MAIN;
+ }
+ if (addr < 0xA000) {
+ return GB_BUS_VRAM;
+ }
+ if (addr < 0xC000) {
+ return GB_BUS_MAIN;
+ }
+ if (addr < 0xFE00) {
+ return GB_is_cgb(gb)? GB_BUS_RAM : GB_BUS_MAIN;
+ }
+ return GB_BUS_INTERNAL;
+}
+
+static uint8_t bitwise_glitch(uint8_t a, uint8_t b, uint8_t c)
+{
+ return ((a ^ c) & (b ^ c)) ^ c;
+}
+
+static uint8_t bitwise_glitch_read(uint8_t a, uint8_t b, uint8_t c)
+{
+ return b | (a & c);
+}
+
+static uint8_t bitwise_glitch_read_increase(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
+{
+ return (b & (a | c | d)) | (a & c & d);
+}
+
+void GB_trigger_oam_bug(GB_gameboy_t *gb, uint16_t address)
+{
+ if (GB_is_cgb(gb)) return;
+
+ if (address >= 0xFE00 && address < 0xFF00) {
+ if (gb->accessed_oam_row != 0xff && gb->accessed_oam_row >= 8) {
+ gb->oam[gb->accessed_oam_row] = bitwise_glitch(gb->oam[gb->accessed_oam_row],
+ gb->oam[gb->accessed_oam_row - 8],
+ gb->oam[gb->accessed_oam_row - 4]);
+ gb->oam[gb->accessed_oam_row + 1] = bitwise_glitch(gb->oam[gb->accessed_oam_row + 1],
+ gb->oam[gb->accessed_oam_row - 7],
+ gb->oam[gb->accessed_oam_row - 3]);
+ for (unsigned i = 2; i < 8; i++) {
+ gb->oam[gb->accessed_oam_row + i] = gb->oam[gb->accessed_oam_row - 8 + i];
+ }
+ }
+ }
+}
+
+void GB_trigger_oam_bug_read(GB_gameboy_t *gb, uint16_t address)
+{
+ if (GB_is_cgb(gb)) return;
+
+ if (address >= 0xFE00 && address < 0xFF00) {
+ if (gb->accessed_oam_row != 0xff && gb->accessed_oam_row >= 8) {
+ gb->oam[gb->accessed_oam_row - 8] =
+ gb->oam[gb->accessed_oam_row] = bitwise_glitch_read(gb->oam[gb->accessed_oam_row],
+ gb->oam[gb->accessed_oam_row - 8],
+ gb->oam[gb->accessed_oam_row - 4]);
+ gb->oam[gb->accessed_oam_row - 7] =
+ gb->oam[gb->accessed_oam_row + 1] = bitwise_glitch_read(gb->oam[gb->accessed_oam_row + 1],
+ gb->oam[gb->accessed_oam_row - 7],
+ gb->oam[gb->accessed_oam_row - 3]);
+ for (unsigned i = 2; i < 8; i++) {
+ gb->oam[gb->accessed_oam_row + i] = gb->oam[gb->accessed_oam_row - 8 + i];
+ }
+ }
+ }
+}
+
+void GB_trigger_oam_bug_read_increase(GB_gameboy_t *gb, uint16_t address)
+{
+ if (GB_is_cgb(gb)) return;
+
+ if (address >= 0xFE00 && address < 0xFF00) {
+ if (gb->accessed_oam_row != 0xff && gb->accessed_oam_row >= 0x20 && gb->accessed_oam_row < 0x98) {
+ gb->oam[gb->accessed_oam_row - 0x8] = bitwise_glitch_read_increase(gb->oam[gb->accessed_oam_row - 0x10],
+ gb->oam[gb->accessed_oam_row - 0x08],
+ gb->oam[gb->accessed_oam_row ],
+ gb->oam[gb->accessed_oam_row - 0x04]
+ );
+ gb->oam[gb->accessed_oam_row - 0x7] = bitwise_glitch_read_increase(gb->oam[gb->accessed_oam_row - 0x0f],
+ gb->oam[gb->accessed_oam_row - 0x07],
+ gb->oam[gb->accessed_oam_row + 0x01],
+ gb->oam[gb->accessed_oam_row - 0x03]
+ );
+ for (unsigned i = 0; i < 8; i++) {
+ gb->oam[gb->accessed_oam_row + i] = gb->oam[gb->accessed_oam_row - 0x10 + i] = gb->oam[gb->accessed_oam_row - 0x08 + i];
+ }
+ }
+ }
+}
+
+static bool is_addr_in_dma_use(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (!gb->dma_steps_left || (gb->dma_cycles < 0 && !gb->is_dma_restarting) || addr >= 0xFE00) return false;
+ return bus_for_addr(gb, addr) == bus_for_addr(gb, gb->dma_current_src);
+}
+
+static bool effective_ir_input(GB_gameboy_t *gb)
+{
+ return gb->infrared_input || (gb->io_registers[GB_IO_RP] & 1) || gb->cart_ir;
+}
+
+static uint8_t read_rom(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (addr < 0x100 && !gb->boot_rom_finished) {
+ return gb->boot_rom[addr];
+ }
+
+ if (addr >= 0x200 && addr < 0x900 && GB_is_cgb(gb) && !gb->boot_rom_finished) {
+ return gb->boot_rom[addr];
+ }
+
+ if (!gb->rom_size) {
+ return 0xFF;
+ }
+ unsigned effective_address = (addr & 0x3FFF) + gb->mbc_rom0_bank * 0x4000;
+ return gb->rom[effective_address & (gb->rom_size - 1)];
+}
+
+static uint8_t read_mbc_rom(GB_gameboy_t *gb, uint16_t addr)
+{
+ unsigned effective_address = (addr & 0x3FFF) + gb->mbc_rom_bank * 0x4000;
+ return gb->rom[effective_address & (gb->rom_size - 1)];
+}
+
+static uint8_t read_vram(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (gb->vram_read_blocked) {
+ return 0xFF;
+ }
+ if (gb->display_state == 22 && GB_is_cgb(gb) && !gb->cgb_double_speed) {
+ if (addr & 0x1000) {
+ addr = gb->last_tile_index_address;
+ }
+ else if (gb->last_tile_data_address & 0x1000) {
+ /* TODO: This is case is more complicated then the rest and differ between revisions
+ It's probably affected by how VRAM is layed out, might be easier after a decap is done*/
+ }
+ else {
+ addr = gb->last_tile_data_address;
+ }
+ }
+ return gb->vram[(addr & 0x1FFF) + (uint16_t) gb->cgb_vram_bank * 0x2000];
+}
+
+static uint8_t read_mbc_ram(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (gb->cartridge_type->mbc_type == GB_HUC3) {
+ switch (gb->huc3_mode) {
+ case 0xC: // RTC read
+ if (gb->huc3_access_flags == 0x2) {
+ return 1;
+ }
+ return gb->huc3_read;
+ case 0xD: // RTC status
+ return 1;
+ case 0xE: // IR mode
+ return effective_ir_input(gb); // TODO: What are the other bits?
+ default:
+ GB_log(gb, "Unsupported HuC-3 mode %x read: %04x\n", gb->huc3_mode, addr);
+ return 1; // TODO: What happens in this case?
+ case 0: // TODO: R/O RAM? (or is it disabled?)
+ case 0xA: // RAM
+ break;
+ }
+ }
+
+ if ((!gb->mbc_ram_enable) &&
+ gb->cartridge_type->mbc_subtype != GB_CAMERA &&
+ gb->cartridge_type->mbc_type != GB_HUC1 &&
+ gb->cartridge_type->mbc_type != GB_HUC3) {
+ return 0xFF;
+ }
+
+ if (gb->cartridge_type->mbc_type == GB_HUC1 && gb->huc1.ir_mode) {
+ return 0xc0 | effective_ir_input(gb);
+ }
+
+ if (gb->cartridge_type->has_rtc && gb->cartridge_type->mbc_type != GB_HUC3 &&
+ gb->mbc3_rtc_mapped && gb->mbc_ram_bank <= 4) {
+ /* RTC read */
+ gb->rtc_latched.high |= ~0xC1; /* Not all bytes in RTC high are used. */
+ return gb->rtc_latched.data[gb->mbc_ram_bank];
+ }
+
+ if (gb->camera_registers_mapped) {
+ return GB_camera_read_register(gb, addr);
+ }
+
+ if (!gb->mbc_ram || !gb->mbc_ram_size) {
+ return 0xFF;
+ }
+
+ if (gb->cartridge_type->mbc_subtype == GB_CAMERA && gb->mbc_ram_bank == 0 && addr >= 0xa100 && addr < 0xaf00) {
+ return GB_camera_read_image(gb, addr - 0xa100);
+ }
+
+ uint8_t effective_bank = gb->mbc_ram_bank;
+ if (gb->cartridge_type->mbc_type == GB_MBC3 && !gb->is_mbc30) {
+ effective_bank &= 0x3;
+ }
+ uint8_t ret = gb->mbc_ram[((addr & 0x1FFF) + effective_bank * 0x2000) & (gb->mbc_ram_size - 1)];
+ if (gb->cartridge_type->mbc_type == GB_MBC2) {
+ ret |= 0xF0;
+ }
+ return ret;
+}
+
+static uint8_t read_ram(GB_gameboy_t *gb, uint16_t addr)
+{
+ return gb->ram[addr & 0x0FFF];
+}
+
+static uint8_t read_banked_ram(GB_gameboy_t *gb, uint16_t addr)
+{
+ return gb->ram[(addr & 0x0FFF) + gb->cgb_ram_bank * 0x1000];
+}
+
+static uint8_t read_high_memory(GB_gameboy_t *gb, uint16_t addr)
+{
+
+ if (gb->hdma_on) {
+ return gb->last_opcode_read;
+ }
+
+ if (addr < 0xFE00) {
+ return read_banked_ram(gb, addr);
+ }
+
+ if (addr < 0xFF00) {
+ if (gb->oam_write_blocked && !GB_is_cgb(gb)) {
+ GB_trigger_oam_bug_read(gb, addr);
+ return 0xff;
+ }
+
+ if ((gb->dma_steps_left && (gb->dma_cycles > 0 || gb->is_dma_restarting))) {
+ /* Todo: Does reading from OAM during DMA causes the OAM bug? */
+ return 0xff;
+ }
+
+ if (gb->oam_read_blocked) {
+ if (!GB_is_cgb(gb)) {
+ if (addr < 0xFEA0) {
+ if (gb->accessed_oam_row == 0) {
+ gb->oam[(addr & 0xf8)] =
+ gb->oam[0] = bitwise_glitch_read(gb->oam[0],
+ gb->oam[(addr & 0xf8)],
+ gb->oam[(addr & 0xfe)]);
+ gb->oam[(addr & 0xf8) + 1] =
+ gb->oam[1] = bitwise_glitch_read(gb->oam[1],
+ gb->oam[(addr & 0xf8) + 1],
+ gb->oam[(addr & 0xfe) | 1]);
+ for (unsigned i = 2; i < 8; i++) {
+ gb->oam[i] = gb->oam[(addr & 0xf8) + i];
+ }
+ }
+ else if (gb->accessed_oam_row == 0xa0) {
+ gb->oam[0x9e] = bitwise_glitch_read(gb->oam[0x9c],
+ gb->oam[0x9e],
+ gb->oam[(addr & 0xf8) | 6]);
+ gb->oam[0x9f] = bitwise_glitch_read(gb->oam[0x9d],
+ gb->oam[0x9f],
+ gb->oam[(addr & 0xf8) | 7]);
+
+ for (unsigned i = 0; i < 8; i++) {
+ gb->oam[(addr & 0xf8) + i] = gb->oam[0x98 + i];
+ }
+ }
+ }
+ }
+ return 0xff;
+ }
+
+ if (addr < 0xFEA0) {
+ return gb->oam[addr & 0xFF];
+ }
+
+ if (gb->oam_read_blocked) {
+ return 0xFF;
+ }
+
+ switch (gb->model) {
+ case GB_MODEL_CGB_E:
+ case GB_MODEL_AGB:
+ return (addr & 0xF0) | ((addr >> 4) & 0xF);
+
+ /*
+ case GB_MODEL_CGB_D:
+ if (addr > 0xfec0) {
+ addr |= 0xf0;
+ }
+ return gb->extra_oam[addr - 0xfea0];
+ */
+
+ case GB_MODEL_CGB_C:
+ /*
+ case GB_MODEL_CGB_B:
+ case GB_MODEL_CGB_A:
+ case GB_MODEL_CGB_0:
+ */
+ addr &= ~0x18;
+ return gb->extra_oam[addr - 0xfea0];
+
+ case GB_MODEL_DMG_B:
+ case GB_MODEL_SGB_NTSC:
+ case GB_MODEL_SGB_PAL:
+ case GB_MODEL_SGB_NTSC_NO_SFC:
+ case GB_MODEL_SGB_PAL_NO_SFC:
+ case GB_MODEL_SGB2:
+ case GB_MODEL_SGB2_NO_SFC:
+ break;
+ }
+ }
+
+ if (addr < 0xFF00) {
+
+ return 0;
+
+ }
+
+ if (addr < 0xFF80) {
+ switch (addr & 0xFF) {
+ case GB_IO_IF:
+ return gb->io_registers[GB_IO_IF] | 0xE0;
+ case GB_IO_TAC:
+ return gb->io_registers[GB_IO_TAC] | 0xF8;
+ case GB_IO_STAT:
+ return gb->io_registers[GB_IO_STAT] | 0x80;
+ case GB_IO_OPRI:
+ if (!GB_is_cgb(gb)) {
+ return 0xFF;
+ }
+ return gb->io_registers[GB_IO_OPRI] | 0xFE;
+
+ case GB_IO_PCM_12:
+ if (!GB_is_cgb(gb)) return 0xFF;
+ return ((gb->apu.is_active[GB_SQUARE_2] ? (gb->apu.samples[GB_SQUARE_2] << 4) : 0) |
+ (gb->apu.is_active[GB_SQUARE_1] ? (gb->apu.samples[GB_SQUARE_1]) : 0)) & (gb->model <= GB_MODEL_CGB_C? gb->apu.pcm_mask[0] : 0xFF);
+ case GB_IO_PCM_34:
+ if (!GB_is_cgb(gb)) return 0xFF;
+ return ((gb->apu.is_active[GB_NOISE] ? (gb->apu.samples[GB_NOISE] << 4) : 0) |
+ (gb->apu.is_active[GB_WAVE] ? (gb->apu.samples[GB_WAVE]) : 0)) & (gb->model <= GB_MODEL_CGB_C? gb->apu.pcm_mask[1] : 0xFF);
+ case GB_IO_JOYP:
+ GB_timing_sync(gb);
+ case GB_IO_TMA:
+ case GB_IO_LCDC:
+ case GB_IO_SCY:
+ case GB_IO_SCX:
+ case GB_IO_LY:
+ case GB_IO_LYC:
+ case GB_IO_BGP:
+ case GB_IO_OBP0:
+ case GB_IO_OBP1:
+ case GB_IO_WY:
+ case GB_IO_WX:
+ case GB_IO_SC:
+ case GB_IO_SB:
+ case GB_IO_DMA:
+ return gb->io_registers[addr & 0xFF];
+ case GB_IO_TIMA:
+ if (gb->tima_reload_state == GB_TIMA_RELOADING) {
+ return 0;
+ }
+ return gb->io_registers[GB_IO_TIMA];
+ case GB_IO_DIV:
+ return gb->div_counter >> 8;
+ case GB_IO_HDMA5:
+ if (!gb->cgb_mode) return 0xFF;
+ return ((gb->hdma_on || gb->hdma_on_hblank)? 0 : 0x80) | ((gb->hdma_steps_left - 1) & 0x7F);
+ case GB_IO_SVBK:
+ if (!gb->cgb_mode) {
+ return 0xFF;
+ }
+ return gb->cgb_ram_bank | ~0x7;
+ case GB_IO_VBK:
+ if (!GB_is_cgb(gb)) {
+ return 0xFF;
+ }
+ return gb->cgb_vram_bank | ~0x1;
+
+ /* Todo: It seems that a CGB in DMG mode can access BGPI and OBPI, but not BGPD and OBPD? */
+ case GB_IO_BGPI:
+ case GB_IO_OBPI:
+ if (!GB_is_cgb(gb)) {
+ return 0xFF;
+ }
+ return gb->io_registers[addr & 0xFF] | 0x40;
+
+ case GB_IO_BGPD:
+ case GB_IO_OBPD:
+ {
+ if (!gb->cgb_mode && gb->boot_rom_finished) {
+ return 0xFF;
+ }
+ if (gb->cgb_palettes_blocked) {
+ return 0xFF;
+ }
+ uint8_t index_reg = (addr & 0xFF) - 1;
+ return ((addr & 0xFF) == GB_IO_BGPD?
+ gb->background_palettes_data :
+ gb->sprite_palettes_data)[gb->io_registers[index_reg] & 0x3F];
+ }
+
+ case GB_IO_KEY1:
+ if (!gb->cgb_mode) {
+ return 0xFF;
+ }
+ return (gb->io_registers[GB_IO_KEY1] & 0x7F) | (gb->cgb_double_speed? 0xFE : 0x7E);
+
+ case GB_IO_RP: {
+ if (!gb->cgb_mode) return 0xFF;
+ /* You will read your own IR LED if it's on. */
+ uint8_t ret = (gb->io_registers[GB_IO_RP] & 0xC1) | 0x3C;
+ if ((gb->io_registers[GB_IO_RP] & 0xC0) == 0xC0 && effective_ir_input(gb)) {
+ ret |= 2;
+ }
+ return ret;
+ }
+ case GB_IO_UNKNOWN2:
+ case GB_IO_UNKNOWN3:
+ return GB_is_cgb(gb)? gb->io_registers[addr & 0xFF] : 0xFF;
+ case GB_IO_UNKNOWN4:
+ return gb->cgb_mode? gb->io_registers[addr & 0xFF] : 0xFF;
+ case GB_IO_UNKNOWN5:
+ return GB_is_cgb(gb)? gb->io_registers[addr & 0xFF] | 0x8F : 0xFF;
+ default:
+ if ((addr & 0xFF) >= GB_IO_NR10 && (addr & 0xFF) <= GB_IO_WAV_END) {
+ return GB_apu_read(gb, addr & 0xFF);
+ }
+ return 0xFF;
+ }
+ /* Hardware registers */
+ return 0;
+ }
+
+ if (addr == 0xFFFF) {
+ /* Interrupt Mask */
+ return gb->interrupt_enable;
+ }
+
+ /* HRAM */
+ return gb->hram[addr - 0xFF80];
+}
+
+static GB_read_function_t * const read_map[] =
+{
+ read_rom, read_rom, read_rom, read_rom, /* 0XXX, 1XXX, 2XXX, 3XXX */
+ read_mbc_rom, read_mbc_rom, read_mbc_rom, read_mbc_rom, /* 4XXX, 5XXX, 6XXX, 7XXX */
+ read_vram, read_vram, /* 8XXX, 9XXX */
+ read_mbc_ram, read_mbc_ram, /* AXXX, BXXX */
+ read_ram, read_banked_ram, /* CXXX, DXXX */
+ read_ram, read_high_memory, /* EXXX FXXX */
+};
+
+void GB_set_read_memory_callback(GB_gameboy_t *gb, GB_read_memory_callback_t callback)
+{
+ gb->read_memory_callback = callback;
+}
+
+uint8_t GB_read_memory(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (gb->n_watchpoints) {
+ GB_debugger_test_read_watchpoint(gb, addr);
+ }
+ if (is_addr_in_dma_use(gb, addr)) {
+ addr = gb->dma_current_src;
+ }
+ uint8_t data = read_map[addr >> 12](gb, addr);
+ GB_apply_cheat(gb, addr, &data);
+ if (gb->read_memory_callback) {
+ data = gb->read_memory_callback(gb, addr, data);
+ }
+ return data;
+}
+
+static void write_mbc(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ switch (gb->cartridge_type->mbc_type) {
+ case GB_NO_MBC: return;
+ case GB_MBC1:
+ switch (addr & 0xF000) {
+ case 0x0000: case 0x1000: gb->mbc_ram_enable = (value & 0xF) == 0xA; break;
+ case 0x2000: case 0x3000: gb->mbc1.bank_low = value; break;
+ case 0x4000: case 0x5000: gb->mbc1.bank_high = value; break;
+ case 0x6000: case 0x7000: gb->mbc1.mode = value; break;
+ }
+ break;
+ case GB_MBC2:
+ switch (addr & 0x4100) {
+ case 0x0000: gb->mbc_ram_enable = (value & 0xF) == 0xA; break;
+ case 0x0100: gb->mbc2.rom_bank = value; break;
+ }
+ break;
+ case GB_MBC3:
+ switch (addr & 0xF000) {
+ case 0x0000: case 0x1000: gb->mbc_ram_enable = (value & 0xF) == 0xA; break;
+ case 0x2000: case 0x3000: gb->mbc3.rom_bank = value; break;
+ case 0x4000: case 0x5000:
+ gb->mbc3.ram_bank = value;
+ gb->mbc3_rtc_mapped = value & 8;
+ break;
+ case 0x6000: case 0x7000:
+ if (!gb->rtc_latch && (value & 1)) { /* Todo: verify condition is correct */
+ memcpy(&gb->rtc_latched, &gb->rtc_real, sizeof(gb->rtc_real));
+ }
+ gb->rtc_latch = value & 1;
+ break;
+ }
+ break;
+ case GB_MBC5:
+ switch (addr & 0xF000) {
+ case 0x0000: case 0x1000: gb->mbc_ram_enable = (value & 0xF) == 0xA; break;
+ case 0x2000: gb->mbc5.rom_bank_low = value; break;
+ case 0x3000: gb->mbc5.rom_bank_high = value; break;
+ case 0x4000: case 0x5000:
+ if (gb->cartridge_type->has_rumble) {
+ if (!!(value & 8) != gb->rumble_state) {
+ gb->rumble_state = !gb->rumble_state;
+ }
+ value &= 7;
+ }
+ gb->mbc5.ram_bank = value;
+ gb->camera_registers_mapped = (value & 0x10) && gb->cartridge_type->mbc_subtype == GB_CAMERA;
+ break;
+ }
+ break;
+ case GB_HUC1:
+ switch (addr & 0xF000) {
+ case 0x0000: case 0x1000: gb->huc1.ir_mode = (value & 0xF) == 0xE; break;
+ case 0x2000: case 0x3000: gb->huc1.bank_low = value; break;
+ case 0x4000: case 0x5000: gb->huc1.bank_high = value; break;
+ case 0x6000: case 0x7000: gb->huc1.mode = value; break;
+ }
+ break;
+ case GB_HUC3:
+ switch (addr & 0xF000) {
+ case 0x0000: case 0x1000:
+ gb->huc3_mode = value & 0xF;
+ gb->mbc_ram_enable = gb->huc3_mode == 0xA;
+ break;
+ case 0x2000: case 0x3000: gb->huc3.rom_bank = value; break;
+ case 0x4000: case 0x5000: gb->huc3.ram_bank = value; break;
+ }
+ break;
+ }
+ GB_update_mbc_mappings(gb);
+}
+
+static void write_vram(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ if (gb->vram_write_blocked) {
+ //GB_log(gb, "Wrote %02x to %04x (VRAM) during mode 3\n", value, addr);
+ return;
+ }
+ /* TODO: not verified */
+ if (gb->display_state == 22 && GB_is_cgb(gb) && !gb->cgb_double_speed) {
+ if (addr & 0x1000) {
+ addr = gb->last_tile_index_address;
+ }
+ else if (gb->last_tile_data_address & 0x1000) {
+ /* TODO: This is case is more complicated then the rest and differ between revisions
+ It's probably affected by how VRAM is layed out, might be easier after a decap is done */
+ }
+ else {
+ addr = gb->last_tile_data_address;
+ }
+ }
+ gb->vram[(addr & 0x1FFF) + (uint16_t) gb->cgb_vram_bank * 0x2000] = value;
+}
+
+static bool huc3_write(GB_gameboy_t *gb, uint8_t value)
+{
+ switch (gb->huc3_mode) {
+ case 0xB: // RTC Write
+ switch (value >> 4) {
+ case 1:
+ if (gb->huc3_access_index < 3) {
+ gb->huc3_read = (gb->huc3_minutes >> (gb->huc3_access_index * 4)) & 0xF;
+ }
+ else if (gb->huc3_access_index < 7) {
+ gb->huc3_read = (gb->huc3_days >> ((gb->huc3_access_index - 3) * 4)) & 0xF;
+ }
+ else {
+ // GB_log(gb, "Attempting to read from unsupported HuC-3 register: %03x\n", gb->huc3_access_index);
+ }
+ gb->huc3_access_index++;
+ break;
+ case 2:
+ case 3:
+ if (gb->huc3_access_index < 3) {
+ gb->huc3_minutes &= ~(0xF << (gb->huc3_access_index * 4));
+ gb->huc3_minutes |= ((value & 0xF) << (gb->huc3_access_index * 4));
+ }
+ else if (gb->huc3_access_index < 7) {
+ gb->huc3_days &= ~(0xF << ((gb->huc3_access_index - 3) * 4));
+ gb->huc3_days |= ((value & 0xF) << ((gb->huc3_access_index - 3) * 4));
+ }
+ else if (gb->huc3_access_index >= 0x58 && gb->huc3_access_index <= 0x5a) {
+ gb->huc3_alarm_minutes &= ~(0xF << ((gb->huc3_access_index - 0x58) * 4));
+ gb->huc3_alarm_minutes |= ((value & 0xF) << ((gb->huc3_access_index - 0x58) * 4));
+ }
+ else if (gb->huc3_access_index >= 0x5b && gb->huc3_access_index <= 0x5e) {
+ gb->huc3_alarm_days &= ~(0xF << ((gb->huc3_access_index - 0x5b) * 4));
+ gb->huc3_alarm_days |= ((value & 0xF) << ((gb->huc3_access_index - 0x5b) * 4));
+ }
+ else if (gb->huc3_access_index == 0x5f) {
+ gb->huc3_alarm_enabled = value & 1;
+ }
+ else {
+ // GB_log(gb, "Attempting to write %x to unsupported HuC-3 register: %03x\n", value & 0xF, gb->huc3_access_index);
+ }
+ if ((value >> 4) == 3) {
+ gb->huc3_access_index++;
+ }
+ break;
+ case 4:
+ gb->huc3_access_index &= 0xF0;
+ gb->huc3_access_index |= value & 0xF;
+ break;
+ case 5:
+ gb->huc3_access_index &= 0x0F;
+ gb->huc3_access_index |= (value & 0xF) << 4;
+ break;
+ case 6:
+ gb->huc3_access_flags = (value & 0xF);
+ break;
+
+ default:
+ break;
+ }
+
+ return true;
+ case 0xD: // RTC status
+ // Not sure what writes here mean, they're always 0xFE
+ return true;
+ case 0xE: { // IR mode
+ bool old_input = effective_ir_input(gb);
+ gb->cart_ir = value & 1;
+ bool new_input = effective_ir_input(gb);
+ if (new_input != old_input) {
+ if (gb->infrared_callback) {
+ gb->infrared_callback(gb, new_input, gb->cycles_since_ir_change);
+ }
+ gb->cycles_since_ir_change = 0;
+ }
+ return true;
+ }
+ case 0xC:
+ return true;
+ default:
+ return false;
+ case 0: // Disabled
+ case 0xA: // RAM
+ return false;
+ }
+}
+
+static void write_mbc_ram(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ if (gb->cartridge_type->mbc_type == GB_HUC3) {
+ if (huc3_write(gb, value)) return;
+ }
+
+ if (gb->camera_registers_mapped) {
+ GB_camera_write_register(gb, addr, value);
+ return;
+ }
+
+ if ((!gb->mbc_ram_enable)
+ && gb->cartridge_type->mbc_type != GB_HUC1) return;
+
+ if (gb->cartridge_type->mbc_type == GB_HUC1 && gb->huc1.ir_mode) {
+ bool old_input = effective_ir_input(gb);
+ gb->cart_ir = value & 1;
+ bool new_input = effective_ir_input(gb);
+ if (new_input != old_input) {
+ if (gb->infrared_callback) {
+ gb->infrared_callback(gb, new_input, gb->cycles_since_ir_change);
+ }
+ gb->cycles_since_ir_change = 0;
+ }
+ return;
+ }
+
+ if (gb->cartridge_type->has_rtc && gb->mbc3_rtc_mapped && gb->mbc_ram_bank <= 4) {
+ gb->rtc_latched.data[gb->mbc_ram_bank] = gb->rtc_real.data[gb->mbc_ram_bank] = value;
+ return;
+ }
+
+ if (!gb->mbc_ram || !gb->mbc_ram_size) {
+ return;
+ }
+
+ uint8_t effective_bank = gb->mbc_ram_bank;
+ if (gb->cartridge_type->mbc_type == GB_MBC3 && !gb->is_mbc30) {
+ effective_bank &= 0x3;
+ }
+
+ gb->mbc_ram[((addr & 0x1FFF) + effective_bank * 0x2000) & (gb->mbc_ram_size - 1)] = value;
+}
+
+static void write_ram(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ gb->ram[addr & 0x0FFF] = value;
+}
+
+static void write_banked_ram(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ gb->ram[(addr & 0x0FFF) + gb->cgb_ram_bank * 0x1000] = value;
+}
+
+static void write_high_memory(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ if (addr < 0xFE00) {
+ GB_log(gb, "Wrote %02x to %04x (RAM Mirror)\n", value, addr);
+ write_banked_ram(gb, addr, value);
+ return;
+ }
+
+ if (addr < 0xFF00) {
+ if (gb->oam_write_blocked) {
+ GB_trigger_oam_bug(gb, addr);
+ return;
+ }
+
+ if ((gb->dma_steps_left && (gb->dma_cycles > 0 || gb->is_dma_restarting))) {
+ /* Todo: Does writing to OAM during DMA causes the OAM bug? */
+ return;
+ }
+
+ if (GB_is_cgb(gb)) {
+ if (addr < 0xFEA0) {
+ gb->oam[addr & 0xFF] = value;
+ }
+ switch (gb->model) {
+ /*
+ case GB_MODEL_CGB_D:
+ if (addr > 0xfec0) {
+ addr |= 0xf0;
+ }
+ gb->extra_oam[addr - 0xfea0] = value;
+ break;
+ */
+ case GB_MODEL_CGB_C:
+ /*
+ case GB_MODEL_CGB_B:
+ case GB_MODEL_CGB_A:
+ case GB_MODEL_CGB_0:
+ */
+ addr &= ~0x18;
+ gb->extra_oam[addr - 0xfea0] = value;
+ break;
+ case GB_MODEL_DMG_B:
+ case GB_MODEL_SGB_NTSC:
+ case GB_MODEL_SGB_PAL:
+ case GB_MODEL_SGB_NTSC_NO_SFC:
+ case GB_MODEL_SGB_PAL_NO_SFC:
+ case GB_MODEL_SGB2:
+ case GB_MODEL_SGB2_NO_SFC:
+ case GB_MODEL_CGB_E:
+ case GB_MODEL_AGB:
+ break;
+ }
+ return;
+ }
+
+ if (addr < 0xFEA0) {
+ if (gb->accessed_oam_row == 0xa0) {
+ for (unsigned i = 0; i < 8; i++) {
+ if ((i & 6) != (addr & 6)) {
+ gb->oam[(addr & 0xf8) + i] = gb->oam[0x98 + i];
+ }
+ else {
+ gb->oam[(addr & 0xf8) + i] = bitwise_glitch(gb->oam[(addr & 0xf8) + i], gb->oam[0x9c], gb->oam[0x98 + i]);
+ }
+ }
+ }
+
+ gb->oam[addr & 0xFF] = value;
+
+ if (gb->accessed_oam_row == 0) {
+ gb->oam[0] = bitwise_glitch(gb->oam[0],
+ gb->oam[(addr & 0xf8)],
+ gb->oam[(addr & 0xfe)]);
+ gb->oam[1] = bitwise_glitch(gb->oam[1],
+ gb->oam[(addr & 0xf8) + 1],
+ gb->oam[(addr & 0xfe) | 1]);
+ for (unsigned i = 2; i < 8; i++) {
+ gb->oam[i] = gb->oam[(addr & 0xf8) + i];
+ }
+ }
+ }
+ else if (gb->accessed_oam_row == 0) {
+ gb->oam[addr & 0x7] = value;
+ }
+ return;
+ }
+
+ /* Todo: Clean this code up: use a function table and move relevant code to display.c and timing.c
+ (APU read and writes are already at apu.c) */
+ if (addr < 0xFF80) {
+ /* Hardware registers */
+ switch (addr & 0xFF) {
+ case GB_IO_WY:
+ if (value == gb->current_line) {
+ gb->wy_triggered = true;
+ }
+ case GB_IO_WX:
+ case GB_IO_IF:
+ case GB_IO_SCX:
+ case GB_IO_SCY:
+ case GB_IO_BGP:
+ case GB_IO_OBP0:
+ case GB_IO_OBP1:
+ case GB_IO_SB:
+ case GB_IO_UNKNOWN2:
+ case GB_IO_UNKNOWN3:
+ case GB_IO_UNKNOWN4:
+ case GB_IO_UNKNOWN5:
+ gb->io_registers[addr & 0xFF] = value;
+ return;
+ case GB_IO_OPRI:
+ if ((!gb->boot_rom_finished || (gb->io_registers[GB_IO_KEY0] & 8)) && GB_is_cgb(gb)) {
+ gb->io_registers[addr & 0xFF] = value;
+ gb->object_priority = (value & 1) ? GB_OBJECT_PRIORITY_X : GB_OBJECT_PRIORITY_INDEX;
+ }
+ else if (gb->cgb_mode) {
+ gb->io_registers[addr & 0xFF] = value;
+
+ }
+ return;
+ case GB_IO_LYC:
+
+ /* TODO: Probably completely wrong in double speed mode */
+
+ /* TODO: This hack is disgusting */
+ if (gb->display_state == 29 && GB_is_cgb(gb)) {
+ gb->ly_for_comparison = 153;
+ GB_STAT_update(gb);
+ gb->ly_for_comparison = 0;
+ }
+
+ gb->io_registers[addr & 0xFF] = value;
+
+ /* These are the states when LY changes, let the display routine call GB_STAT_update for use
+ so it correctly handles T-cycle accurate LYC writes */
+ if (!GB_is_cgb(gb) || (
+ gb->display_state != 35 &&
+ gb->display_state != 26 &&
+ gb->display_state != 15 &&
+ gb->display_state != 16)) {
+
+ /* More hacks to make LYC write conflicts work */
+ if (gb->display_state == 14 && GB_is_cgb(gb)) {
+ gb->ly_for_comparison = 153;
+ GB_STAT_update(gb);
+ gb->ly_for_comparison = -1;
+ }
+ else {
+ GB_STAT_update(gb);
+ }
+ }
+ return;
+
+ case GB_IO_TIMA:
+ if (gb->tima_reload_state != GB_TIMA_RELOADED) {
+ gb->io_registers[GB_IO_TIMA] = value;
+ }
+ return;
+
+ case GB_IO_TMA:
+ gb->io_registers[GB_IO_TMA] = value;
+ if (gb->tima_reload_state != GB_TIMA_RUNNING) {
+ gb->io_registers[GB_IO_TIMA] = value;
+ }
+ return;
+
+ case GB_IO_TAC:
+ GB_emulate_timer_glitch(gb, gb->io_registers[GB_IO_TAC], value);
+ gb->io_registers[GB_IO_TAC] = value;
+ return;
+
+
+ case GB_IO_LCDC:
+ if ((value & 0x80) && !(gb->io_registers[GB_IO_LCDC] & 0x80)) {
+ gb->display_cycles = 0;
+ gb->display_state = 0;
+ if (GB_is_sgb(gb)) {
+ gb->frame_skip_state = GB_FRAMESKIP_SECOND_FRAME_RENDERED;
+ }
+ else if (gb->frame_skip_state == GB_FRAMESKIP_SECOND_FRAME_RENDERED) {
+ gb->frame_skip_state = GB_FRAMESKIP_LCD_TURNED_ON;
+ }
+ }
+ else if (!(value & 0x80) && (gb->io_registers[GB_IO_LCDC] & 0x80)) {
+ /* Sync after turning off LCD */
+ GB_timing_sync(gb);
+ GB_lcd_off(gb);
+ }
+ /* Handle disabling objects while already fetching an object */
+ if ((gb->io_registers[GB_IO_LCDC] & 2) && !(value & 2)) {
+ if (gb->during_object_fetch) {
+ gb->cycles_for_line += gb->display_cycles;
+ gb->display_cycles = 0;
+ gb->object_fetch_aborted = true;
+ }
+ }
+ gb->io_registers[GB_IO_LCDC] = value;
+ if (!(value & 0x20)) {
+ gb->wx_triggered = false;
+ gb->wx166_glitch = false;
+ }
+ return;
+
+ case GB_IO_STAT:
+ /* Delete previous R/W bits */
+ gb->io_registers[GB_IO_STAT] &= 7;
+ /* Set them by value */
+ gb->io_registers[GB_IO_STAT] |= value & ~7;
+ /* Set unused bit to 1 */
+ gb->io_registers[GB_IO_STAT] |= 0x80;
+
+ GB_STAT_update(gb);
+ return;
+
+ case GB_IO_DIV:
+ /* Reset the div state machine */
+ gb->div_state = 0;
+ gb->div_cycles = 0;
+ return;
+
+ case GB_IO_JOYP:
+ if (gb->joyp_write_callback) {
+ gb->joyp_write_callback(gb, value);
+ GB_update_joyp(gb);
+ }
+ else if ((gb->io_registers[GB_IO_JOYP] & 0x30) != (value & 0x30)) {
+ GB_sgb_write(gb, value);
+ gb->io_registers[GB_IO_JOYP] = (value & 0xF0) | (gb->io_registers[GB_IO_JOYP] & 0x0F);
+ GB_update_joyp(gb);
+ }
+ return;
+
+ case GB_IO_BANK:
+ gb->boot_rom_finished = true;
+ return;
+
+ case GB_IO_KEY0:
+ if (GB_is_cgb(gb) && !gb->boot_rom_finished) {
+ gb->cgb_mode = !(value & 0xC); /* The real "contents" of this register aren't quite known yet. */
+ gb->io_registers[GB_IO_KEY0] = value;
+ }
+ return;
+
+ case GB_IO_DMA:
+ if (gb->dma_steps_left) {
+ /* This is not correct emulation, since we're not really delaying the second DMA.
+ One write that should have happened in the first DMA will not happen. However,
+ since that byte will be overwritten by the second DMA before it can actually be
+ read, it doesn't actually matter. */
+ gb->is_dma_restarting = true;
+ }
+ gb->dma_cycles = -7;
+ gb->dma_current_dest = 0;
+ gb->dma_current_src = value << 8;
+ gb->dma_steps_left = 0xa0;
+ gb->io_registers[GB_IO_DMA] = value;
+ return;
+ case GB_IO_SVBK:
+ if (!gb->cgb_mode) {
+ return;
+ }
+ gb->cgb_ram_bank = value & 0x7;
+ if (!gb->cgb_ram_bank) {
+ gb->cgb_ram_bank++;
+ }
+ return;
+ case GB_IO_VBK:
+ if (!gb->cgb_mode) {
+ return;
+ }
+ gb->cgb_vram_bank = value & 0x1;
+ return;
+
+ case GB_IO_BGPI:
+ case GB_IO_OBPI:
+ if (!GB_is_cgb(gb)) {
+ return;
+ }
+ gb->io_registers[addr & 0xFF] = value;
+ return;
+ case GB_IO_BGPD:
+ case GB_IO_OBPD:
+ if (!gb->cgb_mode && gb->boot_rom_finished) {
+ /* Todo: Due to the behavior of a broken Game & Watch Gallery 2 ROM on a real CGB. A proper test ROM
+ is required. */
+ return;
+ }
+
+ uint8_t index_reg = (addr & 0xFF) - 1;
+ if (gb->cgb_palettes_blocked) {
+ if (gb->io_registers[index_reg] & 0x80) {
+ gb->io_registers[index_reg]++;
+ gb->io_registers[index_reg] |= 0x80;
+ }
+ return;
+ }
+ ((addr & 0xFF) == GB_IO_BGPD?
+ gb->background_palettes_data :
+ gb->sprite_palettes_data)[gb->io_registers[index_reg] & 0x3F] = value;
+ GB_palette_changed(gb, (addr & 0xFF) == GB_IO_BGPD, gb->io_registers[index_reg] & 0x3F);
+ if (gb->io_registers[index_reg] & 0x80) {
+ gb->io_registers[index_reg]++;
+ gb->io_registers[index_reg] |= 0x80;
+ }
+ return;
+ case GB_IO_KEY1:
+ if (!gb->cgb_mode) {
+ return;
+ }
+ gb->io_registers[GB_IO_KEY1] = value;
+ return;
+ case GB_IO_HDMA1:
+ if (gb->cgb_mode) {
+ gb->hdma_current_src &= 0xF0;
+ gb->hdma_current_src |= value << 8;
+ }
+ return;
+ case GB_IO_HDMA2:
+ if (gb->cgb_mode) {
+ gb->hdma_current_src &= 0xFF00;
+ gb->hdma_current_src |= value & 0xF0;
+ }
+ return;
+ case GB_IO_HDMA3:
+ if (gb->cgb_mode) {
+ gb->hdma_current_dest &= 0xF0;
+ gb->hdma_current_dest |= value << 8;
+ }
+ return;
+ case GB_IO_HDMA4:
+ if (gb->cgb_mode) {
+ gb->hdma_current_dest &= 0x1F00;
+ gb->hdma_current_dest |= value & 0xF0;
+ }
+ return;
+ case GB_IO_HDMA5:
+ if (!gb->cgb_mode) return;
+ if ((value & 0x80) == 0 && gb->hdma_on_hblank) {
+ gb->hdma_on_hblank = false;
+ return;
+ }
+ gb->hdma_on = (value & 0x80) == 0;
+ gb->hdma_on_hblank = (value & 0x80) != 0;
+ if (gb->hdma_on_hblank && (gb->io_registers[GB_IO_STAT] & 3) == 0) {
+ gb->hdma_on = true;
+ }
+ gb->io_registers[GB_IO_HDMA5] = value;
+ gb->hdma_steps_left = (gb->io_registers[GB_IO_HDMA5] & 0x7F) + 1;
+ /* Todo: Verify this. Gambatte's DMA tests require this. */
+ if (gb->hdma_current_dest + (gb->hdma_steps_left << 4) > 0xFFFF) {
+ gb->hdma_steps_left = (0x10000 - gb->hdma_current_dest) >> 4;
+ }
+ gb->hdma_cycles = -12;
+ return;
+
+ /* Todo: what happens when starting a transfer during a transfer?
+ What happens when starting a transfer during external clock?
+ */
+ case GB_IO_SC:
+ if (!gb->cgb_mode) {
+ value |= 2;
+ }
+ gb->io_registers[GB_IO_SC] = value | (~0x83);
+ if ((value & 0x80) && (value & 0x1) ) {
+ gb->serial_length = gb->cgb_mode && (value & 2)? 16 : 512;
+ gb->serial_count = 0;
+ /* Todo: This is probably incorrect for CGB's faster clock mode. */
+ gb->serial_cycles &= 0xFF;
+ if (gb->serial_transfer_bit_start_callback) {
+ gb->serial_transfer_bit_start_callback(gb, gb->io_registers[GB_IO_SB] & 0x80);
+ }
+ }
+ else {
+ gb->serial_length = 0;
+ }
+ return;
+
+ case GB_IO_RP: {
+ if (!GB_is_cgb(gb)) {
+ return;
+ }
+ bool old_input = effective_ir_input(gb);
+ gb->io_registers[GB_IO_RP] = value;
+ bool new_input = effective_ir_input(gb);
+ if (new_input != old_input) {
+ if (gb->infrared_callback) {
+ gb->infrared_callback(gb, new_input, gb->cycles_since_ir_change);
+ }
+ gb->cycles_since_ir_change = 0;
+ }
+ return;
+ }
+
+ default:
+ if ((addr & 0xFF) >= GB_IO_NR10 && (addr & 0xFF) <= GB_IO_WAV_END) {
+ GB_apu_write(gb, addr & 0xFF, value);
+ return;
+ }
+ GB_log(gb, "Wrote %02x to %04x (HW Register)\n", value, addr);
+ return;
+ }
+ }
+
+ if (addr == 0xFFFF) {
+ /* Interrupt mask */
+ gb->interrupt_enable = value;
+ return;
+ }
+
+ /* HRAM */
+ gb->hram[addr - 0xFF80] = value;
+}
+
+
+
+static GB_write_function_t * const write_map[] =
+{
+ write_mbc, write_mbc, write_mbc, write_mbc, /* 0XXX, 1XXX, 2XXX, 3XXX */
+ write_mbc, write_mbc, write_mbc, write_mbc, /* 4XXX, 5XXX, 6XXX, 7XXX */
+ write_vram, write_vram, /* 8XXX, 9XXX */
+ write_mbc_ram, write_mbc_ram, /* AXXX, BXXX */
+ write_ram, write_banked_ram, /* CXXX, DXXX */
+ write_ram, write_high_memory, /* EXXX FXXX */
+};
+
+void GB_write_memory(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ if (gb->n_watchpoints) {
+ GB_debugger_test_write_watchpoint(gb, addr, value);
+ }
+ if (is_addr_in_dma_use(gb, addr)) {
+ /* Todo: What should happen? Will this affect DMA? Will data be written? What and where? */
+ return;
+ }
+ write_map[addr >> 12](gb, addr, value);
+}
+
+void GB_dma_run(GB_gameboy_t *gb)
+{
+ while (gb->dma_cycles >= 4 && gb->dma_steps_left) {
+ /* Todo: measure this value */
+ gb->dma_cycles -= 4;
+ gb->dma_steps_left--;
+
+ if (gb->dma_current_src < 0xe000) {
+ gb->oam[gb->dma_current_dest++] = GB_read_memory(gb, gb->dma_current_src);
+ }
+ else {
+ /* Todo: Not correct on the CGB */
+ gb->oam[gb->dma_current_dest++] = GB_read_memory(gb, gb->dma_current_src & ~0x2000);
+ }
+
+ /* dma_current_src must be the correct value during GB_read_memory */
+ gb->dma_current_src++;
+ if (!gb->dma_steps_left) {
+ gb->is_dma_restarting = false;
+ }
+ }
+}
+
+void GB_hdma_run(GB_gameboy_t *gb)
+{
+ if (!gb->hdma_on) return;
+
+ while (gb->hdma_cycles >= 0x4) {
+ gb->hdma_cycles -= 0x4;
+
+ GB_write_memory(gb, 0x8000 | (gb->hdma_current_dest++ & 0x1FFF), GB_read_memory(gb, (gb->hdma_current_src++)));
+
+ if ((gb->hdma_current_dest & 0xf) == 0) {
+ if (--gb->hdma_steps_left == 0) {
+ gb->hdma_on = false;
+ gb->hdma_on_hblank = false;
+ gb->hdma_starting = false;
+ gb->io_registers[GB_IO_HDMA5] &= 0x7F;
+ break;
+ }
+ if (gb->hdma_on_hblank) {
+ gb->hdma_on = false;
+ break;
+ }
+ }
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/memory.h b/waterbox/bsnescore/bsnes/gb/Core/memory.h
new file mode 100644
index 0000000000..f0d03907fb
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/memory.h
@@ -0,0 +1,18 @@
+#ifndef memory_h
+#define memory_h
+#include "gb_struct_def.h"
+#include
+
+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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/printer.c b/waterbox/bsnescore/bsnes/gb/Core/printer.c
new file mode 100644
index 0000000000..f04e54ddfe
--- /dev/null
+++ b/waterbox/bsnescore/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_received <<= 1;
+ gb->printer.byte_being_received |= bit_received;
+ gb->printer.bits_received++;
+ if (gb->printer.bits_received == 8) {
+ byte_reieve_completed(gb, gb->printer.byte_being_received);
+ gb->printer.bits_received = 0;
+ gb->printer.byte_being_received = 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;
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/printer.h b/waterbox/bsnescore/bsnes/gb/Core/printer.h
new file mode 100644
index 0000000000..b29650ff7e
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/printer.h
@@ -0,0 +1,64 @@
+#ifndef printer_h
+#define printer_h
+#include
+#include
+#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;
+
+ /* TODO: Delete me. */
+ uint64_t padding;
+
+ uint8_t compression_run_lenth;
+ bool compression_run_is_compressed;
+
+ uint8_t bits_received;
+ uint8_t byte_being_received;
+ bool bit_to_send;
+} GB_printer_t;
+
+
+void GB_connect_printer(GB_gameboy_t *gb, GB_print_image_callback_t callback);
+#endif
diff --git a/waterbox/bsnescore/bsnes/gb/Core/random.c b/waterbox/bsnescore/bsnes/gb/Core/random.c
new file mode 100644
index 0000000000..cc4d4d3a6c
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/random.c
@@ -0,0 +1,38 @@
+#include "random.h"
+#include
+
+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();
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/random.h b/waterbox/bsnescore/bsnes/gb/Core/random.h
new file mode 100644
index 0000000000..8ab0e502c6
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/random.h
@@ -0,0 +1,12 @@
+#ifndef random_h
+#define random_h
+
+#include
+#include
+
+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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/rewind.c b/waterbox/bsnescore/bsnes/gb/Core/rewind.c
new file mode 100644
index 0000000000..c3900d6090
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/rewind.c
@@ -0,0 +1,208 @@
+#include "gb.h"
+#include
+#include
+#include
+#include
+
+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);
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/rewind.h b/waterbox/bsnescore/bsnes/gb/Core/rewind.h
new file mode 100644
index 0000000000..ad54841084
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/rewind.h
@@ -0,0 +1,14 @@
+#ifndef rewind_h
+#define rewind_h
+
+#include
+#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
diff --git a/waterbox/bsnescore/bsnes/gb/Core/rumble.c b/waterbox/bsnescore/bsnes/gb/Core/rumble.c
new file mode 100644
index 0000000000..8cbe20d13e
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/rumble.c
@@ -0,0 +1,53 @@
+#include "rumble.h"
+#include "gb.h"
+
+void GB_set_rumble_mode(GB_gameboy_t *gb, GB_rumble_mode_t mode)
+{
+ gb->rumble_mode = mode;
+ if (gb->rumble_callback) {
+ gb->rumble_callback(gb, 0);
+ }
+}
+
+void GB_handle_rumble(GB_gameboy_t *gb)
+{
+ if (gb->rumble_callback) {
+ if (gb->rumble_mode == GB_RUMBLE_DISABLED) {
+ return;
+ }
+ if (gb->cartridge_type->has_rumble) {
+ if (gb->rumble_on_cycles + gb->rumble_off_cycles) {
+ gb->rumble_callback(gb, gb->rumble_on_cycles / (double)(gb->rumble_on_cycles + gb->rumble_off_cycles));
+ gb->rumble_on_cycles = gb->rumble_off_cycles = 0;
+ }
+ }
+ else if (gb->rumble_mode == GB_RUMBLE_ALL_GAMES) {
+ unsigned volume = (gb->io_registers[GB_IO_NR50] & 7) + 1 + ((gb->io_registers[GB_IO_NR50] >> 4) & 7) + 1;
+ unsigned ch4_volume = volume * (!!(gb->io_registers[GB_IO_NR51] & 8) + !!(gb->io_registers[GB_IO_NR51] & 0x80));
+ unsigned ch1_volume = volume * (!!(gb->io_registers[GB_IO_NR51] & 1) + !!(gb->io_registers[GB_IO_NR51] & 0x10));
+
+ double ch4_rumble = (MIN(gb->apu.noise_channel.sample_length * (gb->apu.noise_channel.narrow? 8 : 1) , 4096) * ((signed) gb->apu.noise_channel.current_volume * gb->apu.noise_channel.current_volume * ch4_volume / 32.0 - 50) - 2048) / 2048.0;
+
+ ch4_rumble = MIN(ch4_rumble, 1.0);
+ ch4_rumble = MAX(ch4_rumble, 0.0);
+
+ double ch1_rumble = 0;
+ if (gb->apu.sweep_enabled && ((gb->io_registers[GB_IO_NR10] >> 4) & 7)) {
+ double sweep_speed = (gb->io_registers[GB_IO_NR10] & 7) / (double)((gb->io_registers[GB_IO_NR10] >> 4) & 7);
+ ch1_rumble = gb->apu.square_channels[GB_SQUARE_1].current_volume * ch1_volume / 32.0 * sweep_speed / 8.0 - 0.5;
+ ch1_rumble = MIN(ch1_rumble, 1.0);
+ ch1_rumble = MAX(ch1_rumble, 0.0);
+ }
+
+ if (!gb->apu.is_active[GB_NOISE]) {
+ ch4_rumble = 0;
+ }
+
+ if (!gb->apu.is_active[GB_SQUARE_1]) {
+ ch1_rumble = 0;
+ }
+
+ gb->rumble_callback(gb, MIN(MAX(ch1_rumble / 2 + ch4_rumble, 0.0), 1.0));
+ }
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/rumble.h b/waterbox/bsnescore/bsnes/gb/Core/rumble.h
new file mode 100644
index 0000000000..eae9f372b6
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/rumble.h
@@ -0,0 +1,17 @@
+#ifndef rumble_h
+#define rumble_h
+
+#include "gb_struct_def.h"
+
+typedef enum {
+ GB_RUMBLE_DISABLED,
+ GB_RUMBLE_CARTRIDGE_ONLY,
+ GB_RUMBLE_ALL_GAMES
+} GB_rumble_mode_t;
+
+#ifdef GB_INTERNAL
+void GB_handle_rumble(GB_gameboy_t *gb);
+#endif
+void GB_set_rumble_mode(GB_gameboy_t *gb, GB_rumble_mode_t mode);
+
+#endif /* rumble_h */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/save_state.c b/waterbox/bsnescore/bsnes/gb/Core/save_state.c
new file mode 100644
index 0000000000..9ef6ae35b7
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/save_state.c
@@ -0,0 +1,413 @@
+#include "gb.h"
+#include
+#include
+
+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, bool fix_broken_windows_saves)
+{
+ uint32_t saved_size = 0;
+ if (fread(&saved_size, 1, sizeof(size), f) != sizeof(size)) {
+ return false;
+ }
+
+ if (fix_broken_windows_saves) {
+ if (saved_size < 4) {
+ return false;
+ }
+ saved_size -= 4;
+ fseek(f, 4, SEEK_CUR);
+ }
+
+ 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_and_update_state_compatibility(GB_gameboy_t *gb, GB_gameboy_t *save)
+{
+ if (save->ram_size == 0 && (&save->ram_size)[-1] == gb->ram_size) {
+ /* This is a save state with a bad printer struct from a 32-bit OS */
+ memcpy(save->extra_oam + 4, save->extra_oam, (uintptr_t)&save->ram_size - (uintptr_t)&save->extra_oam);
+ }
+ 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 (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;
+}
+
+static void sanitize_state(GB_gameboy_t *gb)
+{
+ 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;
+ gb->object_low_line_address &= gb->vram_size & ~1;
+ gb->fetcher_x &= 0x1f;
+ if (gb->lcd_x > gb->position_in_line) {
+ gb->lcd_x = gb->position_in_line;
+ }
+
+ if (gb->object_priority == GB_OBJECT_PRIORITY_UNDEFINED) {
+ gb->object_priority = gb->cgb_mode? GB_OBJECT_PRIORITY_INDEX : GB_OBJECT_PRIORITY_X;
+ }
+}
+
+#define READ_SECTION(gb, f, section) read_section(f, GB_GET_SECTION(gb, section), GB_SECTION_SIZE(section), fix_broken_windows_saves)
+
+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;
+ }
+
+ bool fix_broken_windows_saves = false;
+ if (fread(GB_GET_SECTION(&save, header), 1, GB_SECTION_SIZE(header), f) != GB_SECTION_SIZE(header)) goto error;
+ if (save.magic == 0) {
+ /* Potentially legacy, broken Windows save state */
+ fseek(f, 4, SEEK_SET);
+ if (fread(GB_GET_SECTION(&save, header), 1, GB_SECTION_SIZE(header), f) != GB_SECTION_SIZE(header)) goto error;
+ fix_broken_windows_saves = true;
+ }
+ 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 (!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 (!verify_and_update_state_compatibility(gb, &save)) {
+ errno = -1;
+ goto error;
+ }
+
+ if (GB_is_hle_sgb(gb)) {
+ if (!read_section(f, gb->sgb, sizeof(*gb->sgb), false)) 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;
+
+ sanitize_state(gb);
+
+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, bool fix_broken_windows_saves)
+{
+ 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 (fix_broken_windows_saves) {
+ if (saved_size < 4) {
+ return false;
+ }
+ saved_size -= 4;
+ *buffer += 4;
+ }
+
+ 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), fix_broken_windows_saves)
+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));
+ bool fix_broken_windows_saves = false;
+
+ if (buffer_read(GB_GET_SECTION(&save, header), GB_SECTION_SIZE(header), &buffer, &length) != GB_SECTION_SIZE(header)) return -1;
+ if (save.magic == 0) {
+ /* Potentially legacy, broken Windows save state*/
+ buffer -= GB_SECTION_SIZE(header) - 4;
+ length += GB_SECTION_SIZE(header) - 4;
+ if (buffer_read(GB_GET_SECTION(&save, header), GB_SECTION_SIZE(header), &buffer, &length) != GB_SECTION_SIZE(header)) return -1;
+ fix_broken_windows_saves = true;
+ }
+ 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 (!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_and_update_state_compatibility(gb, &save)) {
+ return -1;
+ }
+
+ if (GB_is_hle_sgb(gb)) {
+ if (!buffer_read_section(&buffer, &length, gb->sgb, sizeof(*gb->sgb), false)) 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));
+
+ sanitize_state(gb);
+
+ return 0;
+}
+
+#undef READ_SECTION
diff --git a/waterbox/bsnescore/bsnes/gb/Core/save_state.h b/waterbox/bsnescore/bsnes/gb/Core/save_state.h
new file mode 100644
index 0000000000..8e5fc4e0e9
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/save_state.h
@@ -0,0 +1,30 @@
+/* Macros to make the GB_gameboy_t struct more future compatible when state saving */
+#ifndef save_state_h
+#define save_state_h
+#include
+
+#define GB_PADDING(type, old_usage) type old_usage##__do_not_use
+
+#ifdef __cplusplus
+/* For bsnes integration. C++ code does not need section information, and throws a fit over certain types such
+ as anonymous enums inside unions */
+#define GB_SECTION(name, ...) __attribute__ ((aligned (8))) __VA_ARGS__
+#else
+#define GB_SECTION(name, ...) __attribute__ ((aligned (8))) union {uint8_t name##_section_start; struct {__VA_ARGS__};}; uint8_t name##_section_end[0]
+#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))
+#endif
+
+#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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/sgb.c b/waterbox/bsnescore/bsnes/gb/Core/sgb.c
new file mode 100644
index 0000000000..c77b0db696
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/sgb.c
@@ -0,0 +1,913 @@
+#include "gb.h"
+#include "random.h"
+#include
+#include
+
+#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,
+ ATTR_CHR = 0x07,
+ 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 const uint16_t built_in_palettes[] =
+{
+ 0x67BF, 0x265B, 0x10B5, 0x2866,
+ 0x637B, 0x3AD9, 0x0956, 0x0000,
+ 0x7F1F, 0x2A7D, 0x30F3, 0x4CE7,
+ 0x57FF, 0x2618, 0x001F, 0x006A,
+ 0x5B7F, 0x3F0F, 0x222D, 0x10EB,
+ 0x7FBB, 0x2A3C, 0x0015, 0x0900,
+ 0x2800, 0x7680, 0x01EF, 0x2FFF,
+ 0x73BF, 0x46FF, 0x0110, 0x0066,
+ 0x533E, 0x2638, 0x01E5, 0x0000,
+ 0x7FFF, 0x2BBF, 0x00DF, 0x2C0A,
+ 0x7F1F, 0x463D, 0x74CF, 0x4CA5,
+ 0x53FF, 0x03E0, 0x00DF, 0x2800,
+ 0x433F, 0x72D2, 0x3045, 0x0822,
+ 0x7FFA, 0x2A5F, 0x0014, 0x0003,
+ 0x1EED, 0x215C, 0x42FC, 0x0060,
+ 0x7FFF, 0x5EF7, 0x39CE, 0x0000,
+ 0x4F5F, 0x630E, 0x159F, 0x3126,
+ 0x637B, 0x121C, 0x0140, 0x0840,
+ 0x66BC, 0x3FFF, 0x7EE0, 0x2C84,
+ 0x5FFE, 0x3EBC, 0x0321, 0x0000,
+ 0x63FF, 0x36DC, 0x11F6, 0x392A,
+ 0x65EF, 0x7DBF, 0x035F, 0x2108,
+ 0x2B6C, 0x7FFF, 0x1CD9, 0x0007,
+ 0x53FC, 0x1F2F, 0x0E29, 0x0061,
+ 0x36BE, 0x7EAF, 0x681A, 0x3C00,
+ 0x7BBE, 0x329D, 0x1DE8, 0x0423,
+ 0x739F, 0x6A9B, 0x7293, 0x0001,
+ 0x5FFF, 0x6732, 0x3DA9, 0x2481,
+ 0x577F, 0x3EBC, 0x456F, 0x1880,
+ 0x6B57, 0x6E1B, 0x5010, 0x0007,
+ 0x0F96, 0x2C97, 0x0045, 0x3200,
+ 0x67FF, 0x2F17, 0x2230, 0x1548,
+};
+
+static const struct {
+ char name[16];
+ unsigned palette_index;
+} palette_assignments[] =
+{
+ {"ZELDA", 5},
+ {"SUPER MARIOLAND", 6},
+ {"MARIOLAND2", 0x14},
+ {"SUPERMARIOLAND3", 2},
+ {"KIRBY DREAM LAND", 0xB},
+ {"HOSHINOKA-BI", 0xB},
+ {"KIRBY'S PINBALL", 3},
+ {"YOSSY NO TAMAGO", 0xC},
+ {"MARIO & YOSHI", 0xC},
+ {"YOSSY NO COOKIE", 4},
+ {"YOSHI'S COOKIE", 4},
+ {"DR.MARIO", 0x12},
+ {"TETRIS", 0x11},
+ {"YAKUMAN", 0x13},
+ {"METROID2", 0x1F},
+ {"KAERUNOTAMENI", 9},
+ {"GOLF", 0x18},
+ {"ALLEY WAY", 0x16},
+ {"BASEBALL", 0xF},
+ {"TENNIS", 0x17},
+ {"F1RACE", 0x1E},
+ {"KID ICARUS", 0xE},
+ {"QIX", 0x19},
+ {"SOLARSTRIKER", 7},
+ {"X", 0x1C},
+ {"GBWARS", 0x15},
+};
+
+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) {
+ if (gb->boot_rom_finished) return;
+
+ 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;
+ }
+ unsigned index = (gb->sgb->command[0] >> 1) & 7;
+ if (index > 5) {
+ return;
+ }
+ memcpy(&gb->sgb->received_header[index * 14], &gb->sgb->command[2], 14);
+ if (gb->sgb->command[0] == 0xfb) {
+ if (gb->sgb->received_header[0x42] != 3 || gb->sgb->received_header[0x47] != 0x33) {
+ gb->sgb->disable_commands = true;
+ for (unsigned i = 0; i < sizeof(palette_assignments) / sizeof(palette_assignments[0]); i++) {
+ if (memcmp(palette_assignments[i].name, &gb->sgb->received_header[0x30], sizeof(palette_assignments[i].name)) == 0) {
+ gb->sgb->effective_palettes[0] = built_in_palettes[palette_assignments[i].palette_index * 4 - 4];
+ gb->sgb->effective_palettes[1] = built_in_palettes[palette_assignments[i].palette_index * 4 + 1 - 4];
+ gb->sgb->effective_palettes[2] = built_in_palettes[palette_assignments[i].palette_index * 4 + 2 - 4];
+ gb->sgb->effective_palettes[3] = built_in_palettes[palette_assignments[i].palette_index * 4 + 3 - 4];
+ break;
+ }
+ }
+ }
+ }
+ 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_CHR: {
+ struct __attribute__((packed)) {
+ uint8_t x, y;
+ uint16_t length;
+ uint8_t direction;
+ uint8_t data[];
+ } *command = (void *)(gb->sgb->command + 1);
+
+ uint16_t count = command->length;
+#ifdef GB_BIG_ENDIAN
+ count = __builtin_bswap16(count);
+#endif
+ uint8_t x = command->x;
+ uint8_t y = command->y;
+ if (x >= 20 || y >= 18 || (count + 3) / 4 > sizeof(gb->sgb->command) - sizeof(*command) - 1) {
+ /* TODO: Verify with the SFC BIOS */
+ break;
+ }
+
+ for (unsigned i = 0; i < count; i++) {
+ uint8_t palette = (command->data[i / 4] >> (((~i) & 3) << 1)) & 3;
+ gb->sgb->attribute_map[x + 20 * y] = palette;
+ if (command->direction) {
+ y++;
+ if (y == 18) {
+ x++;
+ y = 0;
+ if (x == 20) {
+ x = 0;
+ }
+ }
+ }
+ else {
+ x++;
+ if (x == 20) {
+ y++;
+ x = 0;
+ if (y == 18) {
+ y = 0;
+ }
+ }
+ }
+ }
+
+ 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:
+ if (gb->sgb->player_count == 1) {
+ gb->sgb->current_player = 0;
+ }
+ gb->sgb->player_count = (gb->sgb->command[1] & 3) + 1; /* Todo: When breaking save state comaptibility,
+ fix this to be 0 based. */
+ if (gb->sgb->player_count == 3) {
+ gb->sgb->current_player++;
+ }
+ gb->sgb->mlt_lock = true;
+ 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_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;
+ }
+
+ if ((value & 0x20) == 0 && (gb->io_registers[GB_IO_JOYP] & 0x20) != 0) {
+ gb->sgb->mlt_lock ^= true;
+ }
+
+ switch ((value >> 4) & 3) {
+ case 3:
+ gb->sgb->ready_for_pulse = true;
+ if ((gb->sgb->player_count & 1) == 0 && !gb->sgb->mlt_lock) {
+ gb->sgb->current_player++;
+ gb->sgb->current_player &= 3;
+ gb->sgb->mlt_lock = true;
+ }
+ 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 uint32_t convert_rgb15(GB_gameboy_t *gb, uint16_t color)
+{
+ return GB_convert_rgb15(gb, color, false);
+}
+
+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;
+
+ color = r | (g << 5) | (b << 10);
+
+ return GB_convert_rgb15(gb, color, false);
+}
+
+#include
+static void render_boot_animation (GB_gameboy_t *gb)
+{
+#include "graphics/sgb_animation_logo.inc"
+ uint32_t *output = gb->screen;
+ if (gb->border_mode != GB_BORDER_NEVER) {
+ output += 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++;
+ }
+ }
+ if (gb->border_mode != GB_BORDER_NEVER) {
+ 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->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;
+ }
+ }
+ }
+ }
+
+ if (!gb->screen || !gb->rgb_encode_callback || gb->disable_rendering) return;
+
+ 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->mask_mode != MASK_FREEZE) {
+ memcpy(gb->sgb->effective_screen_buffer,
+ gb->sgb->screen_buffer,
+ sizeof(gb->sgb->effective_screen_buffer));
+ }
+
+ if (gb->sgb->intro_animation < INTRO_ANIMATION_LENGTH) {
+ render_boot_animation(gb);
+ }
+ else {
+ uint32_t *output = gb->screen;
+ if (gb->border_mode != GB_BORDER_NEVER) {
+ output += 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];
+ }
+ if (gb->border_mode != GB_BORDER_NEVER) {
+ 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;
+ }
+ if (gb->border_mode != GB_BORDER_NEVER) {
+ 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];
+ }
+ if (gb->border_mode != GB_BORDER_NEVER) {
+ 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;
+ }
+ else if (gb->border_mode == GB_BORDER_NEVER) {
+ continue;
+ }
+ 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;
+ uint32_t *output = gb->screen;
+ if (gb->border_mode == GB_BORDER_NEVER) {
+ output += (tile_x - 6) * 8 + x + ((tile_y - 5) * 8 + y) * 160;
+ }
+ else {
+ output += tile_x * 8 + x + (tile_y * 8 + y) * 256;
+ }
+ if (color == 0) {
+ if (gb_area) continue;
+ *output = colors[0];
+ }
+ else {
+ *output = border_colors[color + palette * 16];
+ }
+ }
+ }
+ }
+ }
+}
+
+void GB_sgb_load_default_data(GB_gameboy_t *gb)
+{
+
+#include "graphics/sgb_border.inc"
+
+ memcpy(gb->sgb->border.map, tilemap, sizeof(tilemap));
+ memcpy(gb->sgb->border.palette, palette, sizeof(palette));
+
+ /* Expand 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] = built_in_palettes[0];
+ gb->sgb->effective_palettes[1] = built_in_palettes[1];
+ gb->sgb->effective_palettes[2] = built_in_palettes[2];
+ gb->sgb->effective_palettes[3] = built_in_palettes[3];
+}
+
+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;
+}
+
diff --git a/waterbox/bsnescore/bsnes/gb/Core/sgb.h b/waterbox/bsnescore/bsnes/gb/Core/sgb.h
new file mode 100644
index 0000000000..aae9f755c9
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/sgb.h
@@ -0,0 +1,67 @@
+#ifndef sgb_h
+#define sgb_h
+#include "gb_struct_def.h"
+#include
+#include
+
+typedef struct GB_sgb_s GB_sgb_t;
+typedef 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];
+ };
+} GB_sgb_border_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 */
+ GB_sgb_border_t 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;
+
+ /* GB Header */
+ uint8_t received_header[0x54];
+
+ /* Multiplayer (cont) */
+ bool mlt_lock;
+};
+
+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
diff --git a/waterbox/bsnescore/bsnes/gb/Core/sm83_cpu.c b/waterbox/bsnescore/bsnes/gb/Core/sm83_cpu.c
new file mode 100644
index 0000000000..3b3ecebb30
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/sm83_cpu.c
@@ -0,0 +1,1590 @@
+#include
+#include
+#include
+#include "gb.h"
+
+
+typedef void GB_opcode_t(GB_gameboy_t *gb, uint8_t opcode);
+
+typedef enum {
+ /* Default behavior. If the CPU writes while another component reads, it reads the old value */
+ GB_CONFLICT_READ_OLD,
+ /* If the CPU writes while another component reads, it reads the new value */
+ GB_CONFLICT_READ_NEW,
+ /* If the CPU and another component write at the same time, the CPU's value "wins" */
+ GB_CONFLICT_WRITE_CPU,
+ /* Register specific values */
+ GB_CONFLICT_STAT_CGB,
+ GB_CONFLICT_STAT_DMG,
+ GB_CONFLICT_PALETTE_DMG,
+ GB_CONFLICT_PALETTE_CGB,
+ GB_CONFLICT_DMG_LCDC,
+ GB_CONFLICT_SGB_LCDC,
+ GB_CONFLICT_WX,
+} GB_conflict_t;
+
+/* Todo: How does double speed mode affect these? */
+static const GB_conflict_t cgb_conflict_map[0x80] = {
+ [GB_IO_IF] = GB_CONFLICT_WRITE_CPU,
+ [GB_IO_LYC] = GB_CONFLICT_WRITE_CPU,
+ [GB_IO_STAT] = GB_CONFLICT_STAT_CGB,
+ [GB_IO_BGP] = GB_CONFLICT_PALETTE_CGB,
+ [GB_IO_OBP0] = GB_CONFLICT_PALETTE_CGB,
+ [GB_IO_OBP1] = GB_CONFLICT_PALETTE_CGB,
+
+ /* Todo: most values not verified, and probably differ between revisions */
+};
+
+/* Todo: verify on an MGB */
+static const GB_conflict_t dmg_conflict_map[0x80] = {
+ [GB_IO_IF] = GB_CONFLICT_WRITE_CPU,
+ [GB_IO_LYC] = GB_CONFLICT_READ_OLD,
+ [GB_IO_LCDC] = GB_CONFLICT_DMG_LCDC,
+ [GB_IO_SCY] = GB_CONFLICT_READ_NEW,
+ [GB_IO_STAT] = GB_CONFLICT_STAT_DMG,
+
+ [GB_IO_BGP] = GB_CONFLICT_PALETTE_DMG,
+ [GB_IO_OBP0] = GB_CONFLICT_PALETTE_DMG,
+ [GB_IO_OBP1] = GB_CONFLICT_PALETTE_DMG,
+ [GB_IO_WY] = GB_CONFLICT_READ_OLD,
+ [GB_IO_WX] = GB_CONFLICT_WX,
+
+ /* Todo: these were not verified at all */
+ [GB_IO_SCX] = GB_CONFLICT_READ_NEW,
+};
+
+/* Todo: Verify on an SGB1 */
+static const GB_conflict_t sgb_conflict_map[0x80] = {
+ [GB_IO_IF] = GB_CONFLICT_WRITE_CPU,
+ [GB_IO_LYC] = GB_CONFLICT_READ_OLD,
+ [GB_IO_LCDC] = GB_CONFLICT_SGB_LCDC,
+ [GB_IO_SCY] = GB_CONFLICT_READ_NEW,
+ [GB_IO_STAT] = GB_CONFLICT_STAT_DMG,
+
+ [GB_IO_BGP] = GB_CONFLICT_READ_NEW,
+ [GB_IO_OBP0] = GB_CONFLICT_READ_NEW,
+ [GB_IO_OBP1] = GB_CONFLICT_READ_NEW,
+ [GB_IO_WY] = GB_CONFLICT_READ_OLD,
+ [GB_IO_WX] = GB_CONFLICT_WX,
+
+ /* Todo: these were not verified at all */
+ [GB_IO_SCX] = GB_CONFLICT_READ_NEW,
+};
+
+static uint8_t cycle_read(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (gb->pending_cycles) {
+ GB_advance_cycles(gb, gb->pending_cycles);
+ }
+ uint8_t ret = GB_read_memory(gb, addr);
+ gb->pending_cycles = 4;
+ return ret;
+}
+
+static uint8_t cycle_read_inc_oam_bug(GB_gameboy_t *gb, uint16_t addr)
+{
+ if (gb->pending_cycles) {
+ GB_advance_cycles(gb, gb->pending_cycles);
+ }
+ GB_trigger_oam_bug_read_increase(gb, addr); /* Todo: test T-cycle timing */
+ uint8_t ret = GB_read_memory(gb, addr);
+ gb->pending_cycles = 4;
+ return ret;
+}
+
+/* A special case for IF during ISR, returns the old value of IF. */
+/* TODO: Verify the timing, it might be wrong in cases where, in the same M cycle, IF
+ is both read be the CPU, modified by the ISR, and modified by an actual interrupt.
+ If this timing proves incorrect, the ISR emulation must be updated so IF reads are
+ timed correctly. */
+static uint8_t cycle_write_if(GB_gameboy_t *gb, uint8_t value)
+{
+ assert(gb->pending_cycles);
+ GB_advance_cycles(gb, gb->pending_cycles);
+ uint8_t old = (gb->io_registers[GB_IO_IF]) & 0x1F;
+ GB_write_memory(gb, 0xFF00 + GB_IO_IF, value);
+ gb->pending_cycles = 4;
+ return old;
+}
+
+static void cycle_write(GB_gameboy_t *gb, uint16_t addr, uint8_t value)
+{
+ assert(gb->pending_cycles);
+ GB_conflict_t conflict = GB_CONFLICT_READ_OLD;
+ if ((addr & 0xFF80) == 0xFF00) {
+ const GB_conflict_t *map = NULL;
+ if (GB_is_cgb(gb)) {
+ map = cgb_conflict_map;
+ }
+ else if (GB_is_sgb(gb)) {
+ map = sgb_conflict_map;
+ }
+ else {
+ map = dmg_conflict_map;
+ }
+ conflict = map[addr & 0x7F];
+ }
+ switch (conflict) {
+ case GB_CONFLICT_READ_OLD:
+ GB_advance_cycles(gb, gb->pending_cycles);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 4;
+ return;
+
+ case GB_CONFLICT_READ_NEW:
+ GB_advance_cycles(gb, gb->pending_cycles - 1);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 5;
+ return;
+
+ case GB_CONFLICT_WRITE_CPU:
+ GB_advance_cycles(gb, gb->pending_cycles + 1);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 3;
+ return;
+
+ /* The DMG STAT-write bug is basically the STAT register being read as FF for a single T-cycle */
+ case GB_CONFLICT_STAT_DMG:
+ GB_advance_cycles(gb, gb->pending_cycles);
+ /* State 7 is the edge between HBlank and OAM mode, and it behaves a bit weird.
+ The OAM interrupt seems to be blocked by HBlank interrupts in that case, despite
+ the timing not making much sense for that.
+ This is a hack to simulate this effect */
+ if (gb->display_state == 7 && (gb->io_registers[GB_IO_STAT] & 0x28) == 0x08) {
+ GB_write_memory(gb, addr, ~0x20);
+ }
+ else {
+ GB_write_memory(gb, addr, 0xFF);
+ }
+ GB_advance_cycles(gb, 1);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 3;
+ return;
+
+ case GB_CONFLICT_STAT_CGB: {
+ /* Todo: Verify this with SCX adjustments */
+ /* The LYC bit behaves differently */
+ uint8_t old_value = GB_read_memory(gb, addr);
+ GB_advance_cycles(gb, gb->pending_cycles);
+ GB_write_memory(gb, addr, (old_value & 0x40) | (value & ~0x40));
+ GB_advance_cycles(gb, 1);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 3;
+ return;
+ }
+
+ /* There is some "time travel" going on with these two values, as it appears
+ that there's some off-by-1-T-cycle timing issue in the PPU implementation.
+
+ This is should be accurate for every measureable scenario, though. */
+
+ case GB_CONFLICT_PALETTE_DMG: {
+ GB_advance_cycles(gb, gb->pending_cycles - 2);
+ uint8_t old_value = GB_read_memory(gb, addr);
+ GB_write_memory(gb, addr, value | old_value);
+ GB_advance_cycles(gb, 1);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 5;
+ return;
+ }
+
+ case GB_CONFLICT_PALETTE_CGB: {
+ GB_advance_cycles(gb, gb->pending_cycles - 2);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 6;
+ return;
+ }
+
+ case GB_CONFLICT_DMG_LCDC: {
+ /* Similar to the palette registers, these interact directly with the LCD, so they appear to be affected by it. Both my DMG (B, blob) and Game Boy Light behave this way though.
+
+ Additionally, LCDC.1 is very nasty because on the it is read both by the FIFO when popping pixels,
+ and the sprite-fetching state machine, and both behave differently when it comes to access conflicts.
+ Hacks ahead.
+ */
+
+
+
+ uint8_t old_value = GB_read_memory(gb, addr);
+ GB_advance_cycles(gb, gb->pending_cycles - 2);
+
+ if (/* gb->model != GB_MODEL_MGB && */ gb->position_in_line == 0 && (old_value & 2) && !(value & 2)) {
+ old_value &= ~2;
+ }
+
+ GB_write_memory(gb, addr, old_value | (value & 1));
+ GB_advance_cycles(gb, 1);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 5;
+ return;
+ }
+
+ case GB_CONFLICT_SGB_LCDC: {
+ /* Simplified version of the above */
+
+ uint8_t old_value = GB_read_memory(gb, addr);
+ GB_advance_cycles(gb, gb->pending_cycles - 2);
+ /* Hack to force aborting object fetch */
+ GB_write_memory(gb, addr, value);
+ GB_write_memory(gb, addr, old_value);
+ GB_advance_cycles(gb, 1);
+ GB_write_memory(gb, addr, value);
+ gb->pending_cycles = 5;
+ return;
+ }
+
+ case GB_CONFLICT_WX:
+ GB_advance_cycles(gb, gb->pending_cycles);
+ GB_write_memory(gb, addr, value);
+ gb->wx_just_changed = true;
+ GB_advance_cycles(gb, 1);
+ gb->wx_just_changed = false;
+ gb->pending_cycles = 3;
+ return;
+ }
+}
+
+static void cycle_no_access(GB_gameboy_t *gb)
+{
+ gb->pending_cycles += 4;
+}
+
+static void cycle_oam_bug(GB_gameboy_t *gb, uint8_t register_id)
+{
+ if (GB_is_cgb(gb)) {
+ /* Slight optimization */
+ gb->pending_cycles += 4;
+ return;
+ }
+ if (gb->pending_cycles) {
+ GB_advance_cycles(gb, gb->pending_cycles);
+ }
+ GB_trigger_oam_bug(gb, gb->registers[register_id]); /* Todo: test T-cycle timing */
+ gb->pending_cycles = 4;
+
+}
+
+static void flush_pending_cycles(GB_gameboy_t *gb)
+{
+ if (gb->pending_cycles) {
+ GB_advance_cycles(gb, gb->pending_cycles);
+ }
+ gb->pending_cycles = 0;
+}
+
+/* Todo: test if multi-byte opcodes trigger the OAM bug correctly */
+
+static void ill(GB_gameboy_t *gb, uint8_t opcode)
+{
+ GB_log(gb, "Illegal Opcode. Halting.\n");
+ gb->interrupt_enable = 0;
+ gb->halted = true;
+}
+
+static void nop(GB_gameboy_t *gb, uint8_t opcode)
+{
+}
+
+static void enter_stop_mode(GB_gameboy_t *gb)
+{
+ gb->stopped = true;
+ gb->oam_ppu_blocked = !gb->oam_read_blocked;
+ gb->vram_ppu_blocked = !gb->vram_read_blocked;
+ gb->cgb_palettes_ppu_blocked = !gb->cgb_palettes_blocked;
+}
+
+static void leave_stop_mode(GB_gameboy_t *gb)
+{
+ /* The CPU takes more time to wake up then the other components */
+ for (unsigned i = 0x200; i--;) {
+ GB_advance_cycles(gb, 0x10);
+ }
+ gb->stopped = false;
+ gb->oam_ppu_blocked = false;
+ gb->vram_ppu_blocked = false;
+ gb->cgb_palettes_ppu_blocked = false;
+}
+
+static void stop(GB_gameboy_t *gb, uint8_t opcode)
+{
+ if (gb->io_registers[GB_IO_KEY1] & 0x1) {
+ flush_pending_cycles(gb);
+ bool needs_alignment = false;
+
+ GB_advance_cycles(gb, 0x4);
+ /* Make sure we keep the CPU ticks aligned correctly when returning from double speed mode */
+ if (gb->double_speed_alignment & 7) {
+ GB_advance_cycles(gb, 0x4);
+ needs_alignment = true;
+ }
+
+ gb->cgb_double_speed ^= true;
+ gb->io_registers[GB_IO_KEY1] = 0;
+
+ enter_stop_mode(gb);
+ leave_stop_mode(gb);
+
+ if (!needs_alignment) {
+ GB_advance_cycles(gb, 0x4);
+ }
+
+ }
+ else {
+ GB_timing_sync(gb);
+ if ((gb->io_registers[GB_IO_JOYP] & 0xF) != 0xF) {
+ /* HW Bug? When STOP is executed while a button is down, the CPU halts forever
+ yet the other hardware keeps running. */
+ gb->interrupt_enable = 0;
+ gb->halted = true;
+ }
+ else {
+ enter_stop_mode(gb);
+ }
+ }
+
+ /* Todo: is PC being actually read? */
+ gb->pc++;
+}
+
+/* Operand naming conventions for functions:
+ r = 8-bit register
+ lr = low 8-bit register
+ hr = high 8-bit register
+ rr = 16-bit register
+ d8 = 8-bit imm
+ d16 = 16-bit imm
+ d.. = [..]
+ cc = condition code (z, nz, c, nc)
+ */
+
+static void ld_rr_d16(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ uint16_t value;
+ register_id = (opcode >> 4) + 1;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ value |= cycle_read_inc_oam_bug(gb, gb->pc++) << 8;
+ gb->registers[register_id] = value;
+}
+
+static void ld_drr_a(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ register_id = (opcode >> 4) + 1;
+ cycle_write(gb, gb->registers[register_id], gb->registers[GB_REGISTER_AF] >> 8);
+}
+
+static void inc_rr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id = (opcode >> 4) + 1;
+ cycle_oam_bug(gb, register_id);
+ gb->registers[register_id]++;
+}
+
+static void inc_hr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ register_id = ((opcode >> 4) + 1) & 0x03;
+ gb->registers[register_id] += 0x100;
+ gb->registers[GB_REGISTER_AF] &= ~(GB_SUBTRACT_FLAG | GB_ZERO_FLAG | GB_HALF_CARRY_FLAG);
+
+ if ((gb->registers[register_id] & 0x0F00) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ((gb->registers[register_id] & 0xFF00) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+static void dec_hr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ register_id = ((opcode >> 4) + 1) & 0x03;
+ gb->registers[register_id] -= 0x100;
+ gb->registers[GB_REGISTER_AF] &= ~(GB_ZERO_FLAG | GB_HALF_CARRY_FLAG);
+ gb->registers[GB_REGISTER_AF] |= GB_SUBTRACT_FLAG;
+
+ if ((gb->registers[register_id] & 0x0F00) == 0xF00) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ((gb->registers[register_id] & 0xFF00) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void ld_hr_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ register_id = ((opcode >> 4) + 1) & 0x03;
+ gb->registers[register_id] &= 0xFF;
+ gb->registers[register_id] |= cycle_read_inc_oam_bug(gb, gb->pc++) << 8;
+}
+
+static void rlca(GB_gameboy_t *gb, uint8_t opcode)
+{
+ bool carry = (gb->registers[GB_REGISTER_AF] & 0x8000) != 0;
+
+ gb->registers[GB_REGISTER_AF] = (gb->registers[GB_REGISTER_AF] & 0xFF00) << 1;
+ if (carry) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG | 0x0100;
+ }
+}
+
+static void rla(GB_gameboy_t *gb, uint8_t opcode)
+{
+ bool bit7 = (gb->registers[GB_REGISTER_AF] & 0x8000) != 0;
+ bool carry = (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) != 0;
+
+ gb->registers[GB_REGISTER_AF] = (gb->registers[GB_REGISTER_AF] & 0xFF00) << 1;
+ if (carry) {
+ gb->registers[GB_REGISTER_AF] |= 0x0100;
+ }
+ if (bit7) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void ld_da16_sp(GB_gameboy_t *gb, uint8_t opcode)
+{
+ /* Todo: Verify order is correct */
+ uint16_t addr;
+ addr = cycle_read_inc_oam_bug(gb, gb->pc++);
+ addr |= cycle_read_inc_oam_bug(gb, gb->pc++) << 8;
+ cycle_write(gb, addr, gb->registers[GB_REGISTER_SP] & 0xFF);
+ cycle_write(gb, addr + 1, gb->registers[GB_REGISTER_SP] >> 8);
+}
+
+static void add_hl_rr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint16_t hl = gb->registers[GB_REGISTER_HL];
+ uint16_t rr;
+ uint8_t register_id;
+ cycle_no_access(gb);
+ register_id = (opcode >> 4) + 1;
+ rr = gb->registers[register_id];
+ gb->registers[GB_REGISTER_HL] = hl + rr;
+ gb->registers[GB_REGISTER_AF] &= ~(GB_SUBTRACT_FLAG | GB_CARRY_FLAG | GB_HALF_CARRY_FLAG);
+
+ /* The meaning of the Half Carry flag is really hard to track -_- */
+ if (((hl & 0xFFF) + (rr & 0xFFF)) & 0x1000) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ( ((unsigned) hl + (unsigned) rr) & 0x10000) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void ld_a_drr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ register_id = (opcode >> 4) + 1;
+ gb->registers[GB_REGISTER_AF] &= 0xFF;
+ gb->registers[GB_REGISTER_AF] |= cycle_read(gb, gb->registers[register_id]) << 8;
+}
+
+static void dec_rr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id = (opcode >> 4) + 1;
+ cycle_oam_bug(gb, register_id);
+ gb->registers[register_id]--;
+}
+
+static void inc_lr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ uint8_t value;
+ register_id = (opcode >> 4) + 1;
+
+ value = (gb->registers[register_id] & 0xFF) + 1;
+ gb->registers[register_id] = (gb->registers[register_id] & 0xFF00) | value;
+
+ gb->registers[GB_REGISTER_AF] &= ~(GB_SUBTRACT_FLAG | GB_ZERO_FLAG | GB_HALF_CARRY_FLAG);
+
+ if ((gb->registers[register_id] & 0x0F) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ((gb->registers[register_id] & 0xFF) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+static void dec_lr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ uint8_t value;
+ register_id = (opcode >> 4) + 1;
+
+ value = (gb->registers[register_id] & 0xFF) - 1;
+ gb->registers[register_id] = (gb->registers[register_id] & 0xFF00) | value;
+
+ gb->registers[GB_REGISTER_AF] &= ~(GB_ZERO_FLAG | GB_HALF_CARRY_FLAG);
+ gb->registers[GB_REGISTER_AF] |= GB_SUBTRACT_FLAG;
+
+ if ((gb->registers[register_id] & 0x0F) == 0xF) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ((gb->registers[register_id] & 0xFF) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void ld_lr_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ register_id = (opcode >> 4) + 1;
+ gb->registers[register_id] &= 0xFF00;
+ gb->registers[register_id] |= cycle_read_inc_oam_bug(gb, gb->pc++);
+}
+
+static void rrca(GB_gameboy_t *gb, uint8_t opcode)
+{
+ bool carry = (gb->registers[GB_REGISTER_AF] & 0x100) != 0;
+
+ gb->registers[GB_REGISTER_AF] = (gb->registers[GB_REGISTER_AF] >> 1) & 0xFF00;
+ if (carry) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG | 0x8000;
+ }
+}
+
+static void rra(GB_gameboy_t *gb, uint8_t opcode)
+{
+ bool bit1 = (gb->registers[GB_REGISTER_AF] & 0x0100) != 0;
+ bool carry = (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) != 0;
+
+ gb->registers[GB_REGISTER_AF] = (gb->registers[GB_REGISTER_AF] >> 1) & 0xFF00;
+ if (carry) {
+ gb->registers[GB_REGISTER_AF] |= 0x8000;
+ }
+ if (bit1) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void jr_r8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ /* Todo: Verify timing */
+ gb->pc += (int8_t)cycle_read_inc_oam_bug(gb, gb->pc) + 1;
+ cycle_no_access(gb);
+}
+
+static bool condition_code(GB_gameboy_t *gb, uint8_t opcode)
+{
+ switch ((opcode >> 3) & 0x3) {
+ case 0:
+ return !(gb->registers[GB_REGISTER_AF] & GB_ZERO_FLAG);
+ case 1:
+ return (gb->registers[GB_REGISTER_AF] & GB_ZERO_FLAG);
+ case 2:
+ return !(gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG);
+ case 3:
+ return (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG);
+ }
+
+ return false;
+}
+
+static void jr_cc_r8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ int8_t offset = cycle_read_inc_oam_bug(gb, gb->pc++);
+ if (condition_code(gb, opcode)) {
+ gb->pc += offset;
+ cycle_no_access(gb);
+ }
+}
+
+static void daa(GB_gameboy_t *gb, uint8_t opcode)
+{
+ int16_t result = gb->registers[GB_REGISTER_AF] >> 8;
+
+ gb->registers[GB_REGISTER_AF] &= ~(0xFF00 | GB_ZERO_FLAG);
+
+ if (gb->registers[GB_REGISTER_AF] & GB_SUBTRACT_FLAG) {
+ if (gb->registers[GB_REGISTER_AF] & GB_HALF_CARRY_FLAG) {
+ result = (result - 0x06) & 0xFF;
+ }
+
+ if (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) {
+ result -= 0x60;
+ }
+ }
+ else {
+ if ((gb->registers[GB_REGISTER_AF] & GB_HALF_CARRY_FLAG) || (result & 0x0F) > 0x09) {
+ result += 0x06;
+ }
+
+ if ((gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) || result > 0x9F) {
+ result += 0x60;
+ }
+ }
+
+ if ((result & 0xFF) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+
+ if ((result & 0x100) == 0x100) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+
+ gb->registers[GB_REGISTER_AF] &= ~GB_HALF_CARRY_FLAG;
+ gb->registers[GB_REGISTER_AF] |= result << 8;
+}
+
+static void cpl(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->registers[GB_REGISTER_AF] ^= 0xFF00;
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG | GB_SUBTRACT_FLAG;
+}
+
+static void scf(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ gb->registers[GB_REGISTER_AF] &= ~(GB_HALF_CARRY_FLAG | GB_SUBTRACT_FLAG);
+}
+
+static void ccf(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->registers[GB_REGISTER_AF] ^= GB_CARRY_FLAG;
+ gb->registers[GB_REGISTER_AF] &= ~(GB_HALF_CARRY_FLAG | GB_SUBTRACT_FLAG);
+}
+
+static void ld_dhli_a(GB_gameboy_t *gb, uint8_t opcode)
+{
+ cycle_write(gb, gb->registers[GB_REGISTER_HL]++, gb->registers[GB_REGISTER_AF] >> 8);
+}
+
+static void ld_dhld_a(GB_gameboy_t *gb, uint8_t opcode)
+{
+ cycle_write(gb, gb->registers[GB_REGISTER_HL]--, gb->registers[GB_REGISTER_AF] >> 8);
+}
+
+static void ld_a_dhli(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->registers[GB_REGISTER_AF] &= 0xFF;
+ gb->registers[GB_REGISTER_AF] |= cycle_read_inc_oam_bug(gb, gb->registers[GB_REGISTER_HL]++) << 8;
+}
+
+static void ld_a_dhld(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->registers[GB_REGISTER_AF] &= 0xFF;
+ gb->registers[GB_REGISTER_AF] |= cycle_read_inc_oam_bug(gb, gb->registers[GB_REGISTER_HL]--) << 8;
+}
+
+static void inc_dhl(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value;
+ value = cycle_read(gb, gb->registers[GB_REGISTER_HL]) + 1;
+ cycle_write(gb, gb->registers[GB_REGISTER_HL], value);
+
+ gb->registers[GB_REGISTER_AF] &= ~(GB_SUBTRACT_FLAG | GB_ZERO_FLAG | GB_HALF_CARRY_FLAG);
+ if ((value & 0x0F) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ((value & 0xFF) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void dec_dhl(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value;
+ value = cycle_read(gb, gb->registers[GB_REGISTER_HL]) - 1;
+ cycle_write(gb, gb->registers[GB_REGISTER_HL], value);
+
+ gb->registers[GB_REGISTER_AF] &= ~( GB_ZERO_FLAG | GB_HALF_CARRY_FLAG);
+ gb->registers[GB_REGISTER_AF] |= GB_SUBTRACT_FLAG;
+ if ((value & 0x0F) == 0x0F) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ((value & 0xFF) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void ld_dhl_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t data = cycle_read_inc_oam_bug(gb, gb->pc++);
+ cycle_write(gb, gb->registers[GB_REGISTER_HL], data);
+}
+
+static uint8_t get_src_value(GB_gameboy_t *gb, 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) {
+ if (src_low) {
+ return gb->registers[GB_REGISTER_AF] >> 8;
+ }
+ return cycle_read(gb, gb->registers[GB_REGISTER_HL]);
+ }
+ if (src_low) {
+ return gb->registers[src_register_id] & 0xFF;
+ }
+ return gb->registers[src_register_id] >> 8;
+}
+
+static void set_src_value(GB_gameboy_t *gb, uint8_t opcode, uint8_t value)
+{
+ 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) {
+ if (src_low) {
+ gb->registers[GB_REGISTER_AF] &= 0xFF;
+ gb->registers[GB_REGISTER_AF] |= value << 8;
+ }
+ else {
+ cycle_write(gb, gb->registers[GB_REGISTER_HL], value);
+ }
+ }
+ else {
+ if (src_low) {
+ gb->registers[src_register_id] &= 0xFF00;
+ gb->registers[src_register_id] |= value;
+ }
+ else {
+ gb->registers[src_register_id] &= 0xFF;
+ gb->registers[src_register_id] |= value << 8;
+ }
+ }
+}
+
+/* The LD r,r instruction is extremely common and extremely simple. Decoding this opcode at runtime is a significent
+ performance hit, so we generate functions for every ld x,y couple (including [hl]) at compile time using macros. */
+
+/* Todo: It's probably wise to do the same to all opcodes. */
+
+#define LD_X_Y(x, y) \
+static void ld_##x##_##y(GB_gameboy_t *gb, uint8_t opcode) \
+{ \
+ gb->x = gb->y;\
+}
+
+#define LD_X_DHL(x) \
+static void ld_##x##_##dhl(GB_gameboy_t *gb, uint8_t opcode) \
+{ \
+gb->x = cycle_read(gb, gb->registers[GB_REGISTER_HL]); \
+}
+
+#define LD_DHL_Y(y) \
+static void ld_##dhl##_##y(GB_gameboy_t *gb, uint8_t opcode) \
+{ \
+cycle_write(gb, gb->registers[GB_REGISTER_HL], gb->y); \
+}
+
+LD_X_Y(b,c) LD_X_Y(b,d) LD_X_Y(b,e) LD_X_Y(b,h) LD_X_Y(b,l) LD_X_DHL(b) LD_X_Y(b,a)
+LD_X_Y(c,b) LD_X_Y(c,d) LD_X_Y(c,e) LD_X_Y(c,h) LD_X_Y(c,l) LD_X_DHL(c) LD_X_Y(c,a)
+LD_X_Y(d,b) LD_X_Y(d,c) LD_X_Y(d,e) LD_X_Y(d,h) LD_X_Y(d,l) LD_X_DHL(d) LD_X_Y(d,a)
+LD_X_Y(e,b) LD_X_Y(e,c) LD_X_Y(e,d) LD_X_Y(e,h) LD_X_Y(e,l) LD_X_DHL(e) LD_X_Y(e,a)
+LD_X_Y(h,b) LD_X_Y(h,c) LD_X_Y(h,d) LD_X_Y(h,e) LD_X_Y(h,l) LD_X_DHL(h) LD_X_Y(h,a)
+LD_X_Y(l,b) LD_X_Y(l,c) LD_X_Y(l,d) LD_X_Y(l,e) LD_X_Y(l,h) LD_X_DHL(l) LD_X_Y(l,a)
+LD_DHL_Y(b) LD_DHL_Y(c) LD_DHL_Y(d) LD_DHL_Y(e) LD_DHL_Y(h) LD_DHL_Y(l) LD_DHL_Y(a)
+LD_X_Y(a,b) LD_X_Y(a,c) LD_X_Y(a,d) LD_X_Y(a,e) LD_X_Y(a,h) LD_X_Y(a,l) LD_X_DHL(a)
+
+// fire the debugger if software breakpoints are enabled
+static void ld_b_b(GB_gameboy_t *gb, uint8_t opcode)
+{
+ if (gb->has_software_breakpoints) {
+ gb->debug_stopped = true;
+ }
+}
+
+static void add_a_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = get_src_value(gb, opcode);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = (a + value) << 8;
+ if ((uint8_t)(a + value) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) + (value & 0xF) > 0x0F) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (((unsigned) a) + ((unsigned) value) > 0xFF) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void adc_a_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a, carry;
+ value = get_src_value(gb, opcode);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ carry = (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) != 0;
+ gb->registers[GB_REGISTER_AF] = (a + value + carry) << 8;
+
+ if ((uint8_t)(a + value + carry) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) + (value & 0xF) + carry > 0x0F) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (((unsigned) a) + ((unsigned) value) + carry > 0xFF) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void sub_a_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = get_src_value(gb, opcode);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = ((a - value) << 8) | GB_SUBTRACT_FLAG;
+ if (a == value) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) < (value & 0xF)) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (a < value) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void sbc_a_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a, carry;
+ value = get_src_value(gb, opcode);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ carry = (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) != 0;
+ gb->registers[GB_REGISTER_AF] = ((a - value - carry) << 8) | GB_SUBTRACT_FLAG;
+
+ if ((uint8_t) (a - value - carry) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) < (value & 0xF) + carry) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (((unsigned) a) - ((unsigned) value) - carry > 0xFF) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void and_a_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = get_src_value(gb, opcode);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = ((a & value) << 8) | GB_HALF_CARRY_FLAG;
+ if ((a & value) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void xor_a_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = get_src_value(gb, opcode);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = (a ^ value) << 8;
+ if ((a ^ value) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void or_a_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = get_src_value(gb, opcode);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = (a | value) << 8;
+ if ((a | value) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void cp_a_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = get_src_value(gb, opcode);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ gb->registers[GB_REGISTER_AF] |= GB_SUBTRACT_FLAG;
+ if (a == value) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) < (value & 0xF)) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (a < value) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void halt(GB_gameboy_t *gb, uint8_t opcode)
+{
+ assert(gb->pending_cycles == 4);
+ gb->pending_cycles = 0;
+ GB_advance_cycles(gb, 4);
+
+ gb->halted = true;
+ /* Despite what some online documentations say, the HALT bug also happens on a CGB, in both CGB and DMG modes. */
+ if (((gb->interrupt_enable & gb->io_registers[GB_IO_IF] & 0x1F) != 0)) {
+ if (gb->ime) {
+ gb->halted = false;
+ gb->pc--;
+ }
+ else {
+ gb->halted = false;
+ gb->halt_bug = true;
+ }
+ }
+ gb->just_halted = true;
+}
+
+static void pop_rr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ register_id = ((opcode >> 4) + 1) & 3;
+ gb->registers[register_id] = cycle_read_inc_oam_bug(gb, gb->registers[GB_REGISTER_SP]++);
+ gb->registers[register_id] |= cycle_read(gb, gb->registers[GB_REGISTER_SP]++) << 8;
+ gb->registers[GB_REGISTER_AF] &= 0xFFF0; // Make sure we don't set impossible flags on F! See Blargg's PUSH AF test.
+}
+
+static void jp_cc_a16(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint16_t addr = cycle_read_inc_oam_bug(gb, gb->pc++);
+ addr |= (cycle_read_inc_oam_bug(gb, gb->pc++) << 8);
+ if (condition_code(gb, opcode)) {
+ cycle_no_access(gb);
+ gb->pc = addr;
+ }
+}
+
+static void jp_a16(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint16_t addr = cycle_read_inc_oam_bug(gb, gb->pc);
+ addr |= (cycle_read_inc_oam_bug(gb, gb->pc + 1) << 8);
+ cycle_no_access(gb);
+ gb->pc = addr;
+
+}
+
+static void call_cc_a16(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint16_t call_addr = gb->pc - 1;
+ uint16_t addr = cycle_read_inc_oam_bug(gb, gb->pc++);
+ addr |= (cycle_read_inc_oam_bug(gb, gb->pc++) << 8);
+ if (condition_code(gb, opcode)) {
+ cycle_oam_bug(gb, GB_REGISTER_SP);
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->pc) >> 8);
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->pc) & 0xFF);
+ gb->pc = addr;
+
+ GB_debugger_call_hook(gb, call_addr);
+ }
+}
+
+static void push_rr(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t register_id;
+ cycle_oam_bug(gb, GB_REGISTER_SP);
+ register_id = ((opcode >> 4) + 1) & 3;
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->registers[register_id]) >> 8);
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->registers[register_id]) & 0xFF);
+}
+
+static void add_a_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = (a + value) << 8;
+ if ((uint8_t) (a + value) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) + (value & 0xF) > 0x0F) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (((unsigned) a) + ((unsigned) value) > 0xFF) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void adc_a_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a, carry;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ carry = (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) != 0;
+ gb->registers[GB_REGISTER_AF] = (a + value + carry) << 8;
+
+ if (gb->registers[GB_REGISTER_AF] == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) + (value & 0xF) + carry > 0x0F) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (((unsigned) a) + ((unsigned) value) + carry > 0xFF) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void sub_a_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = ((a - value) << 8) | GB_SUBTRACT_FLAG;
+ if (a == value) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) < (value & 0xF)) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (a < value) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void sbc_a_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a, carry;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ carry = (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) != 0;
+ gb->registers[GB_REGISTER_AF] = ((a - value - carry) << 8) | GB_SUBTRACT_FLAG;
+
+ if ((uint8_t) (a - value - carry) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) < (value & 0xF) + carry) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (((unsigned) a) - ((unsigned) value) - carry > 0xFF) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void and_a_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = ((a & value) << 8) | GB_HALF_CARRY_FLAG;
+ if ((a & value) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void xor_a_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = (a ^ value) << 8;
+ if ((a ^ value) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void or_a_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] = (a | value) << 8;
+ if ((a | value) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void cp_a_d8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value, a;
+ value = cycle_read_inc_oam_bug(gb, gb->pc++);
+ a = gb->registers[GB_REGISTER_AF] >> 8;
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ gb->registers[GB_REGISTER_AF] |= GB_SUBTRACT_FLAG;
+ if (a == value) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ if ((a & 0xF) < (value & 0xF)) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+ if (a < value) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void rst(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint16_t call_addr = gb->pc - 1;
+ cycle_oam_bug(gb, GB_REGISTER_SP);
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->pc) >> 8);
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->pc) & 0xFF);
+ gb->pc = opcode ^ 0xC7;
+ GB_debugger_call_hook(gb, call_addr);
+}
+
+static void ret(GB_gameboy_t *gb, uint8_t opcode)
+{
+ GB_debugger_ret_hook(gb);
+ gb->pc = cycle_read_inc_oam_bug(gb, gb->registers[GB_REGISTER_SP]++);
+ gb->pc |= cycle_read(gb, gb->registers[GB_REGISTER_SP]++) << 8;
+ cycle_no_access(gb);
+}
+
+static void reti(GB_gameboy_t *gb, uint8_t opcode)
+{
+ ret(gb, opcode);
+ gb->ime = true;
+}
+
+static void ret_cc(GB_gameboy_t *gb, uint8_t opcode)
+{
+ if (condition_code(gb, opcode)) {
+ cycle_no_access(gb);
+ ret(gb, opcode);
+ }
+ else {
+ cycle_no_access(gb);
+ }
+}
+
+static void call_a16(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint16_t call_addr = gb->pc - 1;
+ uint16_t addr = cycle_read_inc_oam_bug(gb, gb->pc++);
+ addr |= (cycle_read_inc_oam_bug(gb, gb->pc++) << 8);
+ cycle_oam_bug(gb, GB_REGISTER_SP);
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->pc) >> 8);
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->pc) & 0xFF);
+ gb->pc = addr;
+ GB_debugger_call_hook(gb, call_addr);
+}
+
+static void ld_da8_a(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t temp = cycle_read_inc_oam_bug(gb, gb->pc++);
+ cycle_write(gb, 0xFF00 + temp, gb->registers[GB_REGISTER_AF] >> 8);
+}
+
+static void ld_a_da8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->registers[GB_REGISTER_AF] &= 0xFF;
+ uint8_t temp = cycle_read_inc_oam_bug(gb, gb->pc++);
+ gb->registers[GB_REGISTER_AF] |= cycle_read(gb, 0xFF00 + temp) << 8;
+}
+
+static void ld_dc_a(GB_gameboy_t *gb, uint8_t opcode)
+{
+ cycle_write(gb, 0xFF00 + (gb->registers[GB_REGISTER_BC] & 0xFF), gb->registers[GB_REGISTER_AF] >> 8);
+}
+
+static void ld_a_dc(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->registers[GB_REGISTER_AF] &= 0xFF;
+ gb->registers[GB_REGISTER_AF] |= cycle_read(gb, 0xFF00 + (gb->registers[GB_REGISTER_BC] & 0xFF)) << 8;
+}
+
+static void add_sp_r8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ int16_t offset;
+ uint16_t sp = gb->registers[GB_REGISTER_SP];
+ offset = (int8_t) cycle_read_inc_oam_bug(gb, gb->pc++);
+ cycle_no_access(gb);
+ cycle_no_access(gb);
+ gb->registers[GB_REGISTER_SP] += offset;
+
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+
+ /* A new instruction, a new meaning for Half Carry! */
+ if ((sp & 0xF) + (offset & 0xF) > 0xF) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ((sp & 0xFF) + (offset & 0xFF) > 0xFF) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void jp_hl(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->pc = gb->registers[GB_REGISTER_HL];
+}
+
+static void ld_da16_a(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint16_t addr;
+ addr = cycle_read_inc_oam_bug(gb, gb->pc++);
+ addr |= cycle_read_inc_oam_bug(gb, gb->pc++) << 8;
+ cycle_write(gb, addr, gb->registers[GB_REGISTER_AF] >> 8);
+}
+
+static void ld_a_da16(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint16_t addr;
+ gb->registers[GB_REGISTER_AF] &= 0xFF;
+ addr = cycle_read_inc_oam_bug(gb, gb->pc++);
+ addr |= cycle_read_inc_oam_bug(gb, gb->pc++) << 8;
+ gb->registers[GB_REGISTER_AF] |= cycle_read(gb, addr) << 8;
+}
+
+static void di(GB_gameboy_t *gb, uint8_t opcode)
+{
+ /* DI is NOT delayed, not even on a CGB. Mooneye's di_timing-GS test fails on a CGB
+ for different reasons. */
+ gb->ime = false;
+}
+
+static void ei(GB_gameboy_t *gb, uint8_t opcode)
+{
+ /* ei is actually "disable interrupts for one instruction, then enable them". */
+ if (!gb->ime && !gb->ime_toggle) {
+ gb->ime_toggle = true;
+ }
+}
+
+static void ld_hl_sp_r8(GB_gameboy_t *gb, uint8_t opcode)
+{
+ int16_t offset;
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ offset = (int8_t) cycle_read_inc_oam_bug(gb, gb->pc++);
+ cycle_no_access(gb);
+ gb->registers[GB_REGISTER_HL] = gb->registers[GB_REGISTER_SP] + offset;
+
+ if ((gb->registers[GB_REGISTER_SP] & 0xF) + (offset & 0xF) > 0xF) {
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ }
+
+ if ((gb->registers[GB_REGISTER_SP] & 0xFF) + (offset & 0xFF) > 0xFF) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+}
+
+static void ld_sp_hl(GB_gameboy_t *gb, uint8_t opcode)
+{
+ gb->registers[GB_REGISTER_SP] = gb->registers[GB_REGISTER_HL];
+ cycle_no_access(gb);
+}
+
+static void rlc_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ bool carry;
+ uint8_t value;
+ value = get_src_value(gb, opcode);
+ carry = (value & 0x80) != 0;
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ set_src_value(gb, opcode, (value << 1) | carry);
+ if (carry) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+ if (!(value << 1)) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void rrc_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ bool carry;
+ uint8_t value;
+ value = get_src_value(gb, opcode);
+ carry = (value & 0x01) != 0;
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ value = (value >> 1) | (carry << 7);
+ set_src_value(gb, opcode, value);
+ if (carry) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+ if (value == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void rl_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ bool carry;
+ uint8_t value;
+ bool bit7;
+ value = get_src_value(gb, opcode);
+ carry = (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) != 0;
+ bit7 = (value & 0x80) != 0;
+
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ value = (value << 1) | carry;
+ set_src_value(gb, opcode, value);
+ if (bit7) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+ if (value == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void rr_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ bool carry;
+ uint8_t value;
+ bool bit1;
+
+ value = get_src_value(gb, opcode);
+ carry = (gb->registers[GB_REGISTER_AF] & GB_CARRY_FLAG) != 0;
+ bit1 = (value & 0x1) != 0;
+
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ value = (value >> 1) | (carry << 7);
+ set_src_value(gb, opcode, value);
+ if (bit1) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+ if (value == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void sla_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value;
+ bool carry;
+ value = get_src_value(gb, opcode);
+ carry = (value & 0x80) != 0;
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ set_src_value(gb, opcode, (value << 1));
+ if (carry) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+ if ((value & 0x7F) == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void sra_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t bit7;
+ uint8_t value;
+ value = get_src_value(gb, opcode);
+ bit7 = value & 0x80;
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ if (value & 1) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+ value = (value >> 1) | bit7;
+ set_src_value(gb, opcode, value);
+ if (value == 0) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void srl_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value;
+ value = get_src_value(gb, opcode);
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ set_src_value(gb, opcode, (value >> 1));
+ if (value & 1) {
+ gb->registers[GB_REGISTER_AF] |= GB_CARRY_FLAG;
+ }
+ if (!(value >> 1)) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void swap_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value;
+ value = get_src_value(gb, opcode);
+ gb->registers[GB_REGISTER_AF] &= 0xFF00;
+ set_src_value(gb, opcode, (value >> 4) | (value << 4));
+ if (!value) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+}
+
+static void bit_r(GB_gameboy_t *gb, uint8_t opcode)
+{
+ uint8_t value;
+ uint8_t bit;
+ value = get_src_value(gb, opcode);
+ bit = 1 << ((opcode >> 3) & 7);
+ if ((opcode & 0xC0) == 0x40) { /* Bit */
+ gb->registers[GB_REGISTER_AF] &= 0xFF00 | GB_CARRY_FLAG;
+ gb->registers[GB_REGISTER_AF] |= GB_HALF_CARRY_FLAG;
+ if (!(bit & value)) {
+ gb->registers[GB_REGISTER_AF] |= GB_ZERO_FLAG;
+ }
+ }
+ else if ((opcode & 0xC0) == 0x80) { /* res */
+ set_src_value(gb, opcode, value & ~bit);
+ }
+ else if ((opcode & 0xC0) == 0xC0) { /* set */
+ set_src_value(gb, opcode, value | bit);
+ }
+}
+
+static void cb_prefix(GB_gameboy_t *gb, uint8_t opcode)
+{
+ opcode = cycle_read_inc_oam_bug(gb, gb->pc++);
+ switch (opcode >> 3) {
+ case 0:
+ rlc_r(gb, opcode);
+ break;
+ case 1:
+ rrc_r(gb, opcode);
+ break;
+ case 2:
+ rl_r(gb, opcode);
+ break;
+ case 3:
+ rr_r(gb, opcode);
+ break;
+ case 4:
+ sla_r(gb, opcode);
+ break;
+ case 5:
+ sra_r(gb, opcode);
+ break;
+ case 6:
+ swap_r(gb, opcode);
+ break;
+ case 7:
+ srl_r(gb, opcode);
+ break;
+ default:
+ bit_r(gb, opcode);
+ 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_b_b, ld_b_c, ld_b_d, ld_b_e, ld_b_h, ld_b_l, ld_b_dhl, ld_b_a, /* 4X */
+ ld_c_b, nop, ld_c_d, ld_c_e, ld_c_h, ld_c_l, ld_c_dhl, ld_c_a,
+ ld_d_b, ld_d_c, nop, ld_d_e, ld_d_h, ld_d_l, ld_d_dhl, ld_d_a, /* 5X */
+ ld_e_b, ld_e_c, ld_e_d, nop, ld_e_h, ld_e_l, ld_e_dhl, ld_e_a,
+ ld_h_b, ld_h_c, ld_h_d, ld_h_e, nop, ld_h_l, ld_h_dhl, ld_h_a, /* 6X */
+ ld_l_b, ld_l_c, ld_l_d, ld_l_e, ld_l_h, nop, ld_l_dhl, ld_l_a,
+ ld_dhl_b, ld_dhl_c, ld_dhl_d, ld_dhl_e, ld_dhl_h, ld_dhl_l, halt, ld_dhl_a, /* 7X */
+ ld_a_b, ld_a_c, ld_a_d, ld_a_e, ld_a_h, ld_a_l, ld_a_dhl, nop,
+ 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_run(GB_gameboy_t *gb)
+{
+ if (gb->hdma_on) {
+ GB_advance_cycles(gb, 4);
+ return;
+ }
+ if (gb->stopped) {
+ GB_timing_sync(gb);
+ GB_advance_cycles(gb, 4);
+ if ((gb->io_registers[GB_IO_JOYP] & 0xF) != 0xF) {
+ leave_stop_mode(gb);
+ GB_advance_cycles(gb, 8);
+ }
+ return;
+ }
+
+ if ((gb->interrupt_enable & 0x10) && (gb->ime || gb->halted)) {
+ GB_timing_sync(gb);
+ }
+
+ if (gb->halted && !GB_is_cgb(gb) && !gb->just_halted) {
+ GB_advance_cycles(gb, 2);
+ }
+
+ uint8_t interrupt_queue = gb->interrupt_enable & gb->io_registers[GB_IO_IF] & 0x1F;
+
+ if (gb->halted) {
+ GB_advance_cycles(gb, (GB_is_cgb(gb) || gb->just_halted) ? 4 : 2);
+ }
+ gb->just_halted = false;
+
+ bool effective_ime = gb->ime;
+ if (gb->ime_toggle) {
+ gb->ime = !gb->ime;
+ gb->ime_toggle = false;
+ }
+
+ /* Wake up from HALT mode without calling interrupt code. */
+ if (gb->halted && !effective_ime && interrupt_queue) {
+ gb->halted = false;
+ }
+
+ /* Call interrupt */
+ else if (effective_ime && interrupt_queue) {
+ gb->halted = false;
+ uint16_t call_addr = gb->pc;
+
+ cycle_no_access(gb);
+ cycle_no_access(gb);
+ GB_trigger_oam_bug(gb, gb->registers[GB_REGISTER_SP]); /* Todo: test T-cycle timing */
+ cycle_no_access(gb);
+
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->pc) >> 8);
+ interrupt_queue = gb->interrupt_enable;
+
+ if (gb->registers[GB_REGISTER_SP] == GB_IO_IF + 0xFF00 + 1) {
+ gb->registers[GB_REGISTER_SP]--;
+ interrupt_queue &= cycle_write_if(gb, (gb->pc) & 0xFF);
+ }
+ else {
+ cycle_write(gb, --gb->registers[GB_REGISTER_SP], (gb->pc) & 0xFF);
+ interrupt_queue &= (gb->io_registers[GB_IO_IF]) & 0x1F;
+ }
+
+ if (interrupt_queue) {
+ uint8_t interrupt_bit = 0;
+ while (!(interrupt_queue & 1)) {
+ interrupt_queue >>= 1;
+ interrupt_bit++;
+ }
+ gb->io_registers[GB_IO_IF] &= ~(1 << interrupt_bit);
+ gb->pc = interrupt_bit * 8 + 0x40;
+ }
+ else {
+ gb->pc = 0;
+ }
+ gb->ime = false;
+ GB_debugger_call_hook(gb, call_addr);
+ }
+ /* Run mode */
+ else if (!gb->halted) {
+ gb->last_opcode_read = cycle_read_inc_oam_bug(gb, gb->pc++);
+ if (gb->halt_bug) {
+ gb->pc--;
+ gb->halt_bug = false;
+ }
+ opcodes[gb->last_opcode_read](gb, gb->last_opcode_read);
+ }
+
+ flush_pending_cycles(gb);
+
+ if (gb->hdma_starting) {
+ gb->hdma_starting = false;
+ gb->hdma_on = true;
+ gb->hdma_cycles = -8;
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/sm83_cpu.h b/waterbox/bsnescore/bsnes/gb/Core/sm83_cpu.h
new file mode 100644
index 0000000000..49fa80b5a9
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/sm83_cpu.h
@@ -0,0 +1,11 @@
+#ifndef sm83_cpu_h
+#define sm83_cpu_h
+#include "gb_struct_def.h"
+#include
+
+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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/sm83_disassembler.c b/waterbox/bsnescore/bsnes/gb/Core/sm83_disassembler.c
new file mode 100644
index 0000000000..7dacd9ebce
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/sm83_disassembler.c
@@ -0,0 +1,789 @@
+#include
+#include
+#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);
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/symbol_hash.c b/waterbox/bsnescore/bsnes/gb/Core/symbol_hash.c
new file mode 100644
index 0000000000..75a7837dd1
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/symbol_hash.c
@@ -0,0 +1,108 @@
+#include "gb.h"
+#include
+#include
+#include
+#include
+
+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);
+
+ 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 unsigned hash_name(const char *name)
+{
+ unsigned 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)
+{
+ unsigned 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)
+{
+ unsigned 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;
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/symbol_hash.h b/waterbox/bsnescore/bsnes/gb/Core/symbol_hash.h
new file mode 100644
index 0000000000..2a03c96bbb
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/symbol_hash.h
@@ -0,0 +1,38 @@
+#ifndef symbol_hash_h
+#define symbol_hash_h
+
+#include
+#include
+#include
+
+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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/timing.c b/waterbox/bsnescore/bsnes/gb/Core/timing.c
new file mode 100644
index 0000000000..965ba27c98
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/timing.c
@@ -0,0 +1,327 @@
+#include "gb.h"
+#ifdef _WIN32
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0500
+#endif
+#include
+#else
+#include
+#endif
+
+static const unsigned GB_TAC_TRIGGER_BITS[] = {512, 8, 32, 128};
+
+#ifndef GB_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)
+{
+ if (gb->stopped) {
+ gb->apu.apu_cycles += 4 << !gb->cgb_double_speed;
+ return;
+ }
+
+ 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)
+{
+ gb->apu.pcm_mask[0] = gb->apu.pcm_mask[1] = 0xFF; // Sort of hacky, but too many cross-component interactions to do it right
+ // Affected by speed boost
+ gb->dma_cycles += cycles;
+
+ GB_timers_run(gb, cycles);
+ if (!gb->stopped) {
+ 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->rumble_state) {
+ gb->rumble_on_cycles++;
+ }
+ else {
+ gb->rumble_off_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->cartridge_type->mbc_type == GB_HUC3) {
+ time_t current_time = time(NULL);
+ while (gb->last_rtc_second / 60 < current_time / 60) {
+ gb->last_rtc_second += 60;
+ gb->huc3_minutes++;
+ if (gb->huc3_minutes == 60 * 24) {
+ gb->huc3_days++;
+ gb->huc3_minutes = 0;
+ }
+ }
+ return;
+ }
+
+ if ((gb->rtc_real.high & 0x40) == 0) { /* is timer running? */
+ time_t current_time = time(NULL);
+
+ while (gb->last_rtc_second + 60 * 60 * 24 < current_time) {
+ gb->last_rtc_second += 60 * 60 * 24;
+ 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;
+ }
+ }
+
+ 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;
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/timing.h b/waterbox/bsnescore/bsnes/gb/Core/timing.h
new file mode 100644
index 0000000000..d4fa07f946
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/timing.h
@@ -0,0 +1,41 @@
+#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_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_STATE_MACHINE(gb, unit, cycles, divisor) \
+static const int __state_machine_divisor = divisor;\
+(gb)->unit##_cycles += cycles; \
+if ((gb)->unit##_cycles <= 0) {\
+ 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 */
diff --git a/waterbox/bsnescore/bsnes/gb/Core/workboy.c b/waterbox/bsnescore/bsnes/gb/Core/workboy.c
new file mode 100644
index 0000000000..3b103796f7
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/workboy.c
@@ -0,0 +1,169 @@
+#include "gb.h"
+#include
+
+static inline uint8_t int_to_bcd(uint8_t i)
+{
+ return (i % 10) + ((i / 10) << 4);
+}
+
+static inline uint8_t bcd_to_int(uint8_t i)
+{
+ return (i & 0xF) + (i >> 4) * 10;
+}
+
+/*
+ Note: This peripheral was never released. This is a hacky software reimplementation of it that allows
+ reaccessing all of the features present in Workboy's ROM. Some of the implementation details are
+ obviously wrong, but without access to the actual hardware, this is the best I can do.
+*/
+
+static void serial_start(GB_gameboy_t *gb, bool bit_received)
+{
+ gb->workboy.byte_being_received <<= 1;
+ gb->workboy.byte_being_received |= bit_received;
+ gb->workboy.bits_received++;
+ if (gb->workboy.bits_received == 8) {
+ gb->workboy.byte_to_send = 0;
+ if (gb->workboy.mode != 'W' && gb->workboy.byte_being_received == 'R') {
+ gb->workboy.byte_to_send = 'D';
+ gb->workboy.key = GB_WORKBOY_NONE;
+ gb->workboy.mode = gb->workboy.byte_being_received;
+ gb->workboy.buffer_index = 1;
+
+ time_t time = gb->workboy_get_time_callback(gb);
+ struct tm tm;
+ tm = *localtime(&time);
+ memset(gb->workboy.buffer, 0, sizeof(gb->workboy.buffer));
+
+ gb->workboy.buffer[0] = 4; // Unknown, unused, but appears to be expected to be 4
+ gb->workboy.buffer[2] = int_to_bcd(tm.tm_sec); // Seconds, BCD
+ gb->workboy.buffer[3] = int_to_bcd(tm.tm_min); // Minutes, BCD
+ gb->workboy.buffer[4] = int_to_bcd(tm.tm_hour); // Hours, BCD
+ gb->workboy.buffer[5] = int_to_bcd(tm.tm_mday); // Days, BCD. Upper most 2 bits are added to Year for some reason
+ gb->workboy.buffer[6] = int_to_bcd(tm.tm_mon + 1); // Months, BCD
+ gb->workboy.buffer[0xF] = tm.tm_year; // Years, plain number, since 1900
+
+ }
+ else if (gb->workboy.mode != 'W' && gb->workboy.byte_being_received == 'W') {
+ gb->workboy.byte_to_send = 'D'; // It is actually unknown what this value should be
+ gb->workboy.key = GB_WORKBOY_NONE;
+ gb->workboy.mode = gb->workboy.byte_being_received;
+ gb->workboy.buffer_index = 0;
+ }
+ else if (gb->workboy.mode != 'W' && (gb->workboy.byte_being_received == 'O' || gb->workboy.mode == 'O')) {
+ gb->workboy.mode = 'O';
+ gb->workboy.byte_to_send = gb->workboy.key;
+ if (gb->workboy.key != GB_WORKBOY_NONE) {
+ if (gb->workboy.key & GB_WORKBOY_REQUIRE_SHIFT) {
+ gb->workboy.key &= ~GB_WORKBOY_REQUIRE_SHIFT;
+ if (gb->workboy.shift_down) {
+ gb->workboy.byte_to_send = gb->workboy.key;
+ gb->workboy.key = GB_WORKBOY_NONE;
+ }
+ else {
+ gb->workboy.byte_to_send = GB_WORKBOY_SHIFT_DOWN;
+ gb->workboy.shift_down = true;
+ }
+ }
+ else if (gb->workboy.key & GB_WORKBOY_FORBID_SHIFT) {
+ gb->workboy.key &= ~GB_WORKBOY_FORBID_SHIFT;
+ if (!gb->workboy.shift_down) {
+ gb->workboy.byte_to_send = gb->workboy.key;
+ gb->workboy.key = GB_WORKBOY_NONE;
+ }
+ else {
+ gb->workboy.byte_to_send = GB_WORKBOY_SHIFT_UP;
+ gb->workboy.shift_down = false;
+ }
+ }
+ else {
+ if (gb->workboy.key == GB_WORKBOY_SHIFT_DOWN) {
+ gb->workboy.shift_down = true;
+ gb->workboy.user_shift_down = true;
+ }
+ else if (gb->workboy.key == GB_WORKBOY_SHIFT_UP) {
+ gb->workboy.shift_down = false;
+ gb->workboy.user_shift_down = false;
+ }
+ gb->workboy.byte_to_send = gb->workboy.key;
+ gb->workboy.key = GB_WORKBOY_NONE;
+ }
+ }
+ }
+ else if (gb->workboy.mode == 'R') {
+ if (gb->workboy.buffer_index / 2 >= sizeof(gb->workboy.buffer)) {
+ gb->workboy.byte_to_send = 0;
+ }
+ else {
+ if (gb->workboy.buffer_index & 1) {
+ gb->workboy.byte_to_send = "0123456789ABCDEF"[gb->workboy.buffer[gb->workboy.buffer_index / 2] & 0xF];
+ }
+ else {
+ gb->workboy.byte_to_send = "0123456789ABCDEF"[gb->workboy.buffer[gb->workboy.buffer_index / 2] >> 4];
+ }
+ gb->workboy.buffer_index++;
+ }
+ }
+ else if (gb->workboy.mode == 'W') {
+ gb->workboy.byte_to_send = 'D';
+ if (gb->workboy.buffer_index < 2) {
+ gb->workboy.buffer_index++;
+ }
+ else if ((gb->workboy.buffer_index - 2) < sizeof(gb->workboy.buffer)) {
+ gb->workboy.buffer[gb->workboy.buffer_index - 2] = gb->workboy.byte_being_received;
+ gb->workboy.buffer_index++;
+ if (gb->workboy.buffer_index - 2 == sizeof(gb->workboy.buffer)) {
+ struct tm tm = {0,};
+ tm.tm_sec = bcd_to_int(gb->workboy.buffer[7]);
+ tm.tm_min = bcd_to_int(gb->workboy.buffer[8]);
+ tm.tm_hour = bcd_to_int(gb->workboy.buffer[9]);
+ tm.tm_mday = bcd_to_int(gb->workboy.buffer[0xA]);
+ tm.tm_mon = bcd_to_int(gb->workboy.buffer[0xB] & 0x3F) - 1;
+ tm.tm_year = (uint8_t)(gb->workboy.buffer[0x14] + (gb->workboy.buffer[0xA] >> 6)); // What were they thinking?
+ gb->workboy_set_time_callback(gb, mktime(&tm));
+ gb->workboy.mode = 'O';
+ }
+ }
+ }
+ gb->workboy.bits_received = 0;
+ gb->workboy.byte_being_received = 0;
+ }
+}
+
+static bool serial_end(GB_gameboy_t *gb)
+{
+ bool ret = gb->workboy.bit_to_send;
+ gb->workboy.bit_to_send = gb->workboy.byte_to_send & 0x80;
+ gb->workboy.byte_to_send <<= 1;
+ return ret;
+}
+
+void GB_connect_workboy(GB_gameboy_t *gb,
+ GB_workboy_set_time_callback set_time_callback,
+ GB_workboy_get_time_callback get_time_callback)
+{
+ memset(&gb->workboy, 0, sizeof(gb->workboy));
+ GB_set_serial_transfer_bit_start_callback(gb, serial_start);
+ GB_set_serial_transfer_bit_end_callback(gb, serial_end);
+ gb->workboy_set_time_callback = set_time_callback;
+ gb->workboy_get_time_callback = get_time_callback;
+}
+
+bool GB_workboy_is_enabled(GB_gameboy_t *gb)
+{
+ return gb->workboy.mode;
+}
+
+void GB_workboy_set_key(GB_gameboy_t *gb, uint8_t key)
+{
+ if (gb->workboy.user_shift_down != gb->workboy.shift_down &&
+ (key & (GB_WORKBOY_REQUIRE_SHIFT | GB_WORKBOY_FORBID_SHIFT)) == 0) {
+ if (gb->workboy.user_shift_down) {
+ key |= GB_WORKBOY_REQUIRE_SHIFT;
+ }
+ else {
+ key |= GB_WORKBOY_FORBID_SHIFT;
+ }
+ }
+ gb->workboy.key = key;
+}
diff --git a/waterbox/bsnescore/bsnes/gb/Core/workboy.h b/waterbox/bsnescore/bsnes/gb/Core/workboy.h
new file mode 100644
index 0000000000..d21f273169
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/gb/Core/workboy.h
@@ -0,0 +1,118 @@
+#ifndef workboy_h
+#define workboy_h
+#include
+#include
+#include
+#include "gb_struct_def.h"
+
+
+typedef struct {
+ uint8_t byte_to_send;
+ bool bit_to_send;
+ uint8_t byte_being_received;
+ uint8_t bits_received;
+ uint8_t mode;
+ uint8_t key;
+ bool shift_down;
+ bool user_shift_down;
+ uint8_t buffer[0x15];
+ uint8_t buffer_index; // In nibbles during read, in bytes during write
+} GB_workboy_t;
+
+typedef void (*GB_workboy_set_time_callback)(GB_gameboy_t *gb, time_t time);
+typedef time_t (*GB_workboy_get_time_callback)(GB_gameboy_t *gb);
+
+enum {
+ GB_WORKBOY_NONE = 0xFF,
+ GB_WORKBOY_REQUIRE_SHIFT = 0x40,
+ GB_WORKBOY_FORBID_SHIFT = 0x80,
+
+ GB_WORKBOY_CLOCK = 1,
+ GB_WORKBOY_TEMPERATURE = 2,
+ GB_WORKBOY_MONEY = 3,
+ GB_WORKBOY_CALCULATOR = 4,
+ GB_WORKBOY_DATE = 5,
+ GB_WORKBOY_CONVERSION = 6,
+ GB_WORKBOY_RECORD = 7,
+ GB_WORKBOY_WORLD = 8,
+ GB_WORKBOY_PHONE = 9,
+ GB_WORKBOY_ESCAPE = 10,
+ GB_WORKBOY_BACKSPACE = 11,
+ GB_WORKBOY_UNKNOWN = 12,
+ GB_WORKBOY_LEFT = 13,
+ GB_WORKBOY_Q = 17,
+ GB_WORKBOY_1 = 17 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_W = 18,
+ GB_WORKBOY_2 = 18 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_E = 19,
+ GB_WORKBOY_3 = 19 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_R = 20,
+ GB_WORKBOY_T = 21,
+ GB_WORKBOY_Y = 22 ,
+ GB_WORKBOY_U = 23 ,
+ GB_WORKBOY_I = 24,
+ GB_WORKBOY_EXCLAMATION_MARK = 24 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_O = 25,
+ GB_WORKBOY_TILDE = 25 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_P = 26,
+ GB_WORKBOY_ASTERISK = 26 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_DOLLAR = 27 | GB_WORKBOY_FORBID_SHIFT,
+ GB_WORKBOY_HASH = 27 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_A = 28,
+ GB_WORKBOY_4 = 28 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_S = 29,
+ GB_WORKBOY_5 = 29 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_D = 30,
+ GB_WORKBOY_6 = 30 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_F = 31,
+ GB_WORKBOY_PLUS = 31 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_G = 32,
+ GB_WORKBOY_MINUS = 32 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_H = 33,
+ GB_WORKBOY_J = 34,
+ GB_WORKBOY_K = 35,
+ GB_WORKBOY_LEFT_PARENTHESIS = 35 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_L = 36,
+ GB_WORKBOY_RIGHT_PARENTHESIS = 36 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_SEMICOLON = 37 | GB_WORKBOY_FORBID_SHIFT,
+ GB_WORKBOY_COLON = 37,
+ GB_WORKBOY_ENTER = 38,
+ GB_WORKBOY_SHIFT_DOWN = 39,
+ GB_WORKBOY_Z = 40,
+ GB_WORKBOY_7 = 40 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_X = 41,
+ GB_WORKBOY_8 = 41 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_C = 42,
+ GB_WORKBOY_9 = 42 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_V = 43,
+ GB_WORKBOY_DECIMAL_POINT = 43 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_B = 44,
+ GB_WORKBOY_PERCENT = 44 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_N = 45,
+ GB_WORKBOY_EQUAL = 45 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_M = 46,
+ GB_WORKBOY_COMMA = 47 | GB_WORKBOY_FORBID_SHIFT,
+ GB_WORKBOY_LT = 47 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_DOT = 48 | GB_WORKBOY_FORBID_SHIFT,
+ GB_WORKBOY_GT = 48 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_SLASH = 49 | GB_WORKBOY_FORBID_SHIFT,
+ GB_WORKBOY_QUESTION_MARK = 49 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_SHIFT_UP = 50,
+ GB_WORKBOY_0 = 51 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_UMLAUT = 51,
+ GB_WORKBOY_SPACE = 52,
+ GB_WORKBOY_QUOTE = 53 | GB_WORKBOY_FORBID_SHIFT,
+ GB_WORKBOY_AT = 53 | GB_WORKBOY_REQUIRE_SHIFT,
+ GB_WORKBOY_UP = 54,
+ GB_WORKBOY_DOWN = 55,
+ GB_WORKBOY_RIGHT = 56,
+};
+
+
+void GB_connect_workboy(GB_gameboy_t *gb,
+ GB_workboy_set_time_callback set_time_callback,
+ GB_workboy_get_time_callback get_time_callback);
+bool GB_workboy_is_enabled(GB_gameboy_t *gb);
+void GB_workboy_set_key(GB_gameboy_t *gb, uint8_t key);
+
+#endif
diff --git a/waterbox/bsnescore/bsnes/heuristics/bs-memory.cpp b/waterbox/bsnescore/bsnes/heuristics/bs-memory.cpp
new file mode 100644
index 0000000000..ffb255c5e4
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/heuristics/bs-memory.cpp
@@ -0,0 +1,33 @@
+namespace Heuristics {
+
+struct BSMemory {
+ BSMemory(vector& data, string location);
+ explicit operator bool() const;
+ auto manifest() const -> string;
+
+private:
+ vector& data;
+ string location;
+};
+
+BSMemory::BSMemory(vector& 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;
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/heuristics/game-boy.cpp b/waterbox/bsnescore/bsnes/heuristics/game-boy.cpp
new file mode 100644
index 0000000000..411a1cca3d
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/heuristics/game-boy.cpp
@@ -0,0 +1,298 @@
+namespace Heuristics {
+
+struct GameBoy {
+ GameBoy(vector& data, string location);
+ explicit operator bool() const;
+ auto manifest() const -> string;
+
+private:
+ auto read(uint offset) const -> uint8_t { return data[headerAddress + offset]; }
+
+ vector& data;
+ string location;
+ uint headerAddress = 0;
+};
+
+GameBoy::GameBoy(vector& 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;
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/heuristics/heuristics.cpp b/waterbox/bsnescore/bsnes/heuristics/heuristics.cpp
new file mode 100644
index 0000000000..c564ac9567
--- /dev/null
+++ b/waterbox/bsnescore/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;
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/heuristics/heuristics.hpp b/waterbox/bsnescore/bsnes/heuristics/heuristics.hpp
new file mode 100644
index 0000000000..a65dafa083
--- /dev/null
+++ b/waterbox/bsnescore/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;
+};
+
+}
diff --git a/waterbox/bsnescore/bsnes/heuristics/super-famicom.cpp b/waterbox/bsnescore/bsnes/heuristics/super-famicom.cpp
new file mode 100644
index 0000000000..674196e3eb
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/heuristics/super-famicom.cpp
@@ -0,0 +1,605 @@
+namespace Heuristics {
+
+struct SuperFamicom {
+ SuperFamicom(vector& 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& data;
+ string location;
+ uint headerAddress = 0;
+};
+
+SuperFamicom::SuperFamicom(vector& 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 == 'X') 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"};
+ if(E == 0x12) region = {"SCN"};
+ }
+
+ return region ? region : "NTSC";
+}
+
+auto SuperFamicom::videoRegion() const -> string {
+ auto region = data[headerAddress + 0x29];
+ if(region == 0x00) return "NTSC"; //JPN
+ if(region == 0x01) return "NTSC"; //USA
+ if(region == 0x0b) return "NTSC"; //ROC
+ if(region == 0x0d) return "NTSC"; //KOR
+ if(region == 0x0f) return "NTSC"; //CAN
+ if(region == 0x10) return "NTSC"; //BRA
+ return "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 == 'X') 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-";
+ }
+
+ //this game's title ovewrites the map mode with '!' (0x21), but is a LOROM game
+ if(title() == "YUYU NO QUIZ DE GO!GO") mode = "LOROM-";
+
+ 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 {
+ return size() - firmwareRomSize();
+}
+
+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;
+}
+
+//detect if any firmware is appended to the ROM image, and return its size if so
+auto SuperFamicom::firmwareRomSize() const -> uint {
+ auto cartridgeTypeLo = data[headerAddress + 0x26] & 15;
+ auto cartridgeTypeHi = data[headerAddress + 0x26] >> 4;
+ auto cartridgeSubType = data[headerAddress + 0x0f];
+
+ if(serial() == "042J" || (cartridgeTypeLo == 0x3 && cartridgeTypeHi == 0xe)) {
+ //Game Boy
+ if((size() & 0x7fff) == 0x100) return 0x100;
+ }
+
+ if(cartridgeTypeLo >= 0x3 && cartridgeTypeHi == 0xf && cartridgeSubType == 0x10) {
+ //Hitachi HG51BS169
+ if((size() & 0x7fff) == 0xc00) return 0xc00;
+ }
+
+ if(cartridgeTypeLo >= 0x3 && cartridgeTypeHi == 0x0) {
+ //NEC uPD7725
+ if((size() & 0x7fff) == 0x2000) return 0x2000;
+ }
+
+ if(cartridgeTypeLo >= 0x3 && cartridgeTypeHi == 0xf && cartridgeSubType == 0x01) {
+ //NEC uPD96050
+ if((size() & 0xffff) == 0xd000) return 0xd000;
+ }
+
+ if(cartridgeTypeLo >= 0x3 && cartridgeTypeHi == 0xf && cartridgeSubType == 0x02) {
+ //ARM6
+ if((size() & 0x3ffff) == 0x28000) return 0x28000;
+ }
+
+ return 0;
+}
+
+auto SuperFamicom::ramSize() const -> uint {
+ auto ramSize = data[headerAddress + 0x28] & 15;
+ if(ramSize > 8) ramSize = 8;
+ if(ramSize > 0) return 1024 << ramSize;
+ return 0;
+}
+
+auto SuperFamicom::expansionRamSize() const -> uint {
+ if(data[headerAddress + 0x2a] == 0x33) {
+ auto ramSize = data[headerAddress + 0x0d] & 15;
+ if(ramSize > 8) ramSize = 8;
+ if(ramSize > 0) 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";
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/nall/adaptive-array.hpp b/waterbox/bsnescore/bsnes/nall/adaptive-array.hpp
new file mode 100644
index 0000000000..9ca84e7c6c
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/nall/adaptive-array.hpp
@@ -0,0 +1,64 @@
+//deprecated
+
+#pragma once
+
+#include
+#include
+
+namespace nall {
+
+template
+struct adaptive_array {
+ auto capacity() const -> uint { return Capacity; }
+ auto size() const -> uint { return _size; }
+
+ auto reset() -> void {
+ for(uint n : range(_size)) _pool.t[n].~T();
+ _size = 0;
+ }
+
+ auto operator[](uint index) -> T& {
+ #ifdef DEBUG
+ struct out_of_bounds {};
+ if(index >= Capacity) throw out_of_bounds{};
+ #endif
+ return _pool.t[index];
+ }
+
+ auto operator[](uint index) const -> const T& {
+ #ifdef DEBUG
+ struct out_of_bounds {};
+ if(index >= Capacity) throw out_of_bounds{};
+ #endif
+ return _pool.t[index];
+ }
+
+ auto append() -> T& {
+ new(_pool.t + _size) T;
+ return _pool.t[_size++];
+ }
+
+ auto append(const T& value) -> void {
+ new(_pool.t + _size++) T(value);
+ }
+
+ auto append(T&& value) -> void {
+ new(_pool.t + _size++) T(move(value));
+ }
+
+ auto begin() { return &_pool.t[0]; }
+ auto end() { return &_pool.t[_size]; }
+
+ auto begin() const { return &_pool.t[0]; }
+ auto end() const { return &_pool.t[_size]; }
+
+private:
+ union U {
+ U() {}
+ ~U() {}
+ T t[Capacity];
+ } _pool;
+ uint _size = 0;
+};
+
+}
diff --git a/waterbox/bsnescore/bsnes/nall/algorithm.hpp b/waterbox/bsnescore/bsnes/nall/algorithm.hpp
new file mode 100644
index 0000000000..34565f11e2
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/nall/algorithm.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include
+
+#undef min
+#undef max
+
+namespace nall {
+
+template constexpr auto min(const T& t, const U& u) -> T {
+ return t < u ? t : (T)u;
+}
+
+template constexpr auto min(const T& t, const U& u, P&&... p) -> T {
+ return t < u ? min(t, forward(p)...) : min(u, forward
(p)...);
+}
+
+template constexpr auto max(const T& t, const U& u) -> T {
+ return t > u ? t : (T)u;
+}
+
+template constexpr auto max(const T& t, const U& u, P&&... p) -> T {
+ return t > u ? max(t, forward(p)...) : max(u, forward
(p)...);
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/nall/any.hpp b/waterbox/bsnescore/bsnes/nall/any.hpp
new file mode 100644
index 0000000000..d7e789a9fa
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/nall/any.hpp
@@ -0,0 +1,83 @@
+#pragma once
+
+#include
+#include
+
+namespace nall {
+
+struct any {
+ any() = default;
+ any(const any& source) { operator=(source); }
+ any(any&& source) { operator=(move(source)); }
+ template any(const T& value) { operator=(value); }
+ ~any() { reset(); }
+
+ explicit operator bool() const { return container; }
+ auto reset() -> void { if(container) { delete container; container = nullptr; } }
+
+ auto type() const -> const std::type_info& {
+ return container ? container->type() : typeid(void);
+ }
+
+ template auto is() const -> bool {
+ return type() == typeid(typename remove_reference::type);
+ }
+
+ template auto get() -> T& {
+ if(!is()) throw;
+ return static_cast::type>*>(container)->value;
+ }
+
+ template auto get() const -> const T& {
+ if(!is()) throw;
+ return static_cast::type>*>(container)->value;
+ }
+
+ template auto get(const T& fallback) const -> const T& {
+ if(!is()) return fallback;
+ return static_cast::type>*>(container)->value;
+ }
+
+ template auto operator=(const T& value) -> any& {
+ using auto_t = typename conditional::value, typename remove_extent::type>::type*, T>::type;
+
+ if(type() == typeid(auto_t)) {
+ static_cast*>(container)->value = (auto_t)value;
+ } else {
+ if(container) delete container;
+ container = new holder((auto_t)value);
+ }
+
+ return *this;
+ }
+
+ auto operator=(const any& source) -> any& {
+ if(container) { delete container; container = nullptr; }
+ if(source.container) container = source.container->copy();
+ return *this;
+ }
+
+ auto operator=(any&& source) -> any& {
+ if(container) delete container;
+ container = source.container;
+ source.container = nullptr;
+ return *this;
+ }
+
+private:
+ struct placeholder {
+ virtual ~placeholder() = default;
+ virtual auto type() const -> const std::type_info& = 0;
+ virtual auto copy() const -> placeholder* = 0;
+ };
+ placeholder* container = nullptr;
+
+ template struct holder : placeholder {
+ holder(const T& value) : value(value) {}
+ auto type() const -> const std::type_info& { return typeid(T); }
+ auto copy() const -> placeholder* { return new holder(value); }
+ T value;
+ };
+};
+
+}
diff --git a/waterbox/bsnescore/bsnes/nall/arguments.hpp b/waterbox/bsnescore/bsnes/nall/arguments.hpp
new file mode 100644
index 0000000000..6fb706d13a
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/nall/arguments.hpp
@@ -0,0 +1,161 @@
+#pragma once
+
+#include
+#include
+#include
+#include
+
+namespace nall {
+
+struct Arguments {
+ Arguments(int argc, char** argv);
+ Arguments(vector arguments);
+
+ explicit operator bool() const { return (bool)arguments; }
+ auto size() const -> uint { return arguments.size(); }
+
+ auto operator[](uint index) -> string& { return arguments[index]; }
+ auto operator[](uint index) const -> const string& { return arguments[index]; }
+
+ auto programPath() const -> string;
+ auto programName() const -> string;
+ auto programLocation() const -> string;
+
+ auto find(string_view name) const -> bool;
+ auto find(string_view name, bool& argument) const -> bool;
+ auto find(string_view name, string& argument) const -> bool;
+
+ auto begin() const { return arguments.begin(); }
+ auto end() const { return arguments.end(); }
+
+ auto rbegin() const { return arguments.rbegin(); }
+ auto rend() const { return arguments.rend(); }
+
+ auto take() -> string;
+ auto take(string_view name) -> bool;
+ auto take(string_view name, bool& argument) -> bool;
+ auto take(string_view name, string& argument) -> bool;
+
+ auto begin() { return arguments.begin(); }
+ auto end() { return arguments.end(); }
+
+ auto rbegin() { return arguments.rbegin(); }
+ auto rend() { return arguments.rend(); }
+
+private:
+ auto construct() -> void;
+
+ string programArgument;
+ vector arguments;
+};
+
+inline auto Arguments::construct() -> void {
+ if(!arguments) return;
+
+ //extract and pre-process program argument
+ programArgument = arguments.takeFirst();
+ programArgument = {Path::real(programArgument), Location::file(programArgument)};
+
+ //normalize path and file arguments
+ for(auto& argument : arguments) {
+ if(directory::exists(argument)) argument.transform("\\", "/").trimRight("/").append("/");
+ else if(file::exists(argument)) argument.transform("\\", "/").trimRight("/");
+ }
+}
+
+inline Arguments::Arguments(int argc, char** argv) {
+ #if defined(PLATFORM_WINDOWS)
+ utf8_arguments(argc, argv);
+ #endif
+ for(uint index : range(argc)) arguments.append(argv[index]);
+ construct();
+}
+
+inline Arguments::Arguments(vector arguments) {
+ this->arguments = arguments;
+ construct();
+}
+
+inline auto Arguments::programPath() const -> string {
+ return Location::path(programArgument);
+}
+
+inline auto Arguments::programName() const -> string {
+ return Location::file(programArgument);
+}
+
+inline auto Arguments::programLocation() const -> string {
+ return programArgument;
+}
+
+inline auto Arguments::find(string_view name) const -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+inline auto Arguments::find(string_view name, bool& argument) const -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name) && arguments.size() >= index
+ && (arguments[index + 1] == "true" || arguments[index + 1] == "false")) {
+ argument = arguments[index + 1] == "true";
+ return true;
+ }
+ }
+ return false;
+}
+
+inline auto Arguments::find(string_view name, string& argument) const -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name) && arguments.size() >= index) {
+ argument = arguments[index + 1];
+ return true;
+ }
+ }
+ return false;
+}
+
+//
+
+inline auto Arguments::take() -> string {
+ if(!arguments) return {};
+ return arguments.takeFirst();
+}
+
+inline auto Arguments::take(string_view name) -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name)) {
+ arguments.remove(index);
+ return true;
+ }
+ }
+ return false;
+}
+
+inline auto Arguments::take(string_view name, bool& argument) -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name) && arguments.size() > index + 1
+ && (arguments[index + 1] == "true" || arguments[index + 1] == "false")) {
+ arguments.remove(index);
+ argument = arguments.take(index) == "true";
+ return true;
+ }
+ }
+ return false;
+}
+
+inline auto Arguments::take(string_view name, string& argument) -> bool {
+ for(uint index : range(arguments.size())) {
+ if(arguments[index].match(name) && arguments.size() > index + 1) {
+ arguments.remove(index);
+ argument = arguments.take(index);
+ return true;
+ }
+ }
+ return false;
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/nall/arithmetic.hpp b/waterbox/bsnescore/bsnes/nall/arithmetic.hpp
new file mode 100644
index 0000000000..388370f158
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/nall/arithmetic.hpp
@@ -0,0 +1,89 @@
+#pragma once
+
+//multi-precision arithmetic
+//warning: each size is quadratically more expensive than the size before it!
+
+#include
+#include
+#include
+#include
+
+#include
+
+namespace nall {
+ template struct ArithmeticNatural;
+ template<> struct ArithmeticNatural< 8> { using type = uint8_t; };
+ template<> struct ArithmeticNatural< 16> { using type = uint16_t; };
+ template<> struct ArithmeticNatural< 32> { using type = uint32_t; };
+ template<> struct ArithmeticNatural< 64> { using type = uint64_t; };
+ #if INTMAX_BITS >= 128
+ template<> struct ArithmeticNatural<128> { using type = uint128_t; };
+ #endif
+}
+
+#if INTMAX_BITS < 128
+#define PairBits 128
+#define TypeBits 64
+#define HalfBits 32
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+#endif
+
+#define PairBits 256
+#define TypeBits 128
+#define HalfBits 64
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 512
+#define TypeBits 256
+#define HalfBits 128
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 1024
+#define TypeBits 512
+#define HalfBits 256
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 2048
+#define TypeBits 1024
+#define HalfBits 512
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 4096
+#define TypeBits 2048
+#define HalfBits 1024
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+#define PairBits 8192
+#define TypeBits 4096
+#define HalfBits 2048
+#include
+#undef PairBits
+#undef TypeBits
+#undef HalfBits
+
+namespace nall {
+ //TODO: these types are for expressing smaller bit ranges in class interfaces
+ //for instance, XChaCha20 taking a 192-bit nonce
+ //however, they still allow more bits than expressed ...
+ //some sort of wrapper needs to be devised to ensure these sizes are masked and wrap appropriately
+
+ using uint192_t = uint256_t;
+}
diff --git a/waterbox/bsnescore/bsnes/nall/arithmetic/barrett.hpp b/waterbox/bsnescore/bsnes/nall/arithmetic/barrett.hpp
new file mode 100644
index 0000000000..ffbaf7c5c9
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/nall/arithmetic/barrett.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+namespace nall {
+
+template struct BarrettReduction {
+ using type = typename ArithmeticNatural<1 * Bits>::type;
+ using pair = typename ArithmeticNatural<2 * Bits>::type;
+
+ explicit BarrettReduction(type modulo) : modulo(modulo), factor(pair(1) + -pair(modulo) / modulo) {}
+
+ //return => value % modulo
+ inline auto operator()(pair value) const -> type {
+ pair hi, lo;
+ mul(value, factor, hi, lo);
+ pair remainder = value - hi * modulo;
+ return remainder < modulo ? remainder : remainder - modulo;
+ }
+
+private:
+ const pair modulo;
+ const pair factor;
+};
+
+template auto operator%(T value, const BarrettReduction& modulo) {
+ return modulo(value);
+}
+
+}
diff --git a/waterbox/bsnescore/bsnes/nall/arithmetic/natural.hpp b/waterbox/bsnescore/bsnes/nall/arithmetic/natural.hpp
new file mode 100644
index 0000000000..fcc902b8df
--- /dev/null
+++ b/waterbox/bsnescore/bsnes/nall/arithmetic/natural.hpp
@@ -0,0 +1,342 @@
+#define ConcatenateType(Size) uint##Size##_t
+#define DeclareType(Size) ConcatenateType(Size)
+
+#define Pair DeclareType(PairBits)
+#define Type DeclareType(TypeBits)
+#define Half DeclareType(HalfBits)
+
+//pick the larger of two types to prevent unnecessary data clamping
+#define Cast (typename conditional= sizeof(T), Pair, T>::type)
+
+namespace nall {
+//namespace Arithmetic {
+
+struct Pair {
+ Pair() = default;
+ explicit constexpr Pair(const Pair& source) : hi(source.hi), lo(source.lo) {}
+ template constexpr Pair(const Hi& hi, const Lo& lo) : hi(hi), lo(lo) {}
+ template Pair(const T& source) { _set(*this, source); }
+
+ explicit operator bool() const { return hi | lo; }
+ template operator T() const { T value; _get(*this, value); return value; }
+
+ auto operator+() const -> Pair { return *this; }
+ auto operator-() const -> Pair { return Pair(0) - *this; }
+ auto operator~() const -> Pair { return {~hi, ~lo}; }
+ auto operator!() const -> bool { return !(hi || lo); }
+
+ auto operator++() -> Pair& { lo++; hi += lo == 0; return *this; }
+ auto operator--() -> Pair& { hi -= lo == 0; lo--; return *this; }
+
+ auto operator++(int) -> Pair { Pair r = *this; lo++; hi += lo == 0; return r; }
+ auto operator--(int) -> Pair { Pair r = *this; hi -= lo == 0; lo--; return r; }
+
+ auto operator* (const Pair& rhs) const -> Pair { return mul(*this, rhs); }
+ auto operator/ (const Pair& rhs) const -> Pair { Pair q, r; div(*this, rhs, q, r); return q; }
+ auto operator% (const Pair& rhs) const -> Pair { Pair q, r; div(*this, rhs, q, r); return r; }
+ auto operator+ (const Pair& rhs) const -> Pair { return {hi + rhs.hi + (lo + rhs.lo < lo), lo + rhs.lo}; }
+ auto operator- (const Pair& rhs) const -> Pair { return {hi - rhs.hi - (lo - rhs.lo > lo), lo - rhs.lo}; }
+ auto operator<<(const Pair& rhs) const -> Pair { return shl(*this, rhs); }
+ auto operator>>(const Pair& rhs) const -> Pair { return shr(*this, rhs); }
+ auto operator& (const Pair& rhs) const -> Pair { return {hi & rhs.hi, lo & rhs.lo}; }
+ auto operator| (const Pair& rhs) const -> Pair { return {hi | rhs.hi, lo | rhs.lo}; }
+ auto operator^ (const Pair& rhs) const -> Pair { return {hi ^ rhs.hi, lo ^ rhs.lo}; }
+ auto operator==(const Pair& rhs) const -> bool { return hi == rhs.hi && lo == rhs.lo; }
+ auto operator!=(const Pair& rhs) const -> bool { return hi != rhs.hi || lo != rhs.lo; }
+ auto operator>=(const Pair& rhs) const -> bool { return hi > rhs.hi || (hi == rhs.hi && lo >= rhs.lo); }
+ auto operator<=(const Pair& rhs) const -> bool { return hi < rhs.hi || (hi == rhs.hi && lo <= rhs.lo); }
+ auto operator> (const Pair& rhs) const -> bool { return hi > rhs.hi || (hi == rhs.hi && lo > rhs.lo); }
+ auto operator< (const Pair& rhs) const -> bool { return hi < rhs.hi || (hi == rhs.hi && lo < rhs.lo); }
+
+ template auto& operator*= (const T& rhs) { return *this = *this * Pair(rhs); }
+ template auto& operator/= (const T& rhs) { return *this = *this / Pair(rhs); }
+ template auto& operator%= (const T& rhs) { return *this = *this % Pair(rhs); }
+ template auto& operator+= (const T& rhs) { return *this = *this + Pair(rhs); }
+ template auto& operator-= (const T& rhs) { return *this = *this - Pair(rhs); }
+ template auto& operator<<=(const T& rhs) { return *this = *this << Pair(rhs); }
+ template auto& operator>>=(const T& rhs) { return *this = *this >> Pair(rhs); }
+ template auto& operator&= (const T& rhs) { return *this = *this & Pair(rhs); }
+ template auto& operator|= (const T& rhs) { return *this = *this | Pair(rhs); }
+ template